/*

* Copyright (c) 2009-2010 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:

* Database cache manager.

*

*/

#include <e32base.h>

#include <cmpluginbaseeng.h>

#include <cmdefconnvalues.h>

#include <cmpluginembdestinationdef.h>

#include <es_sock.h>    // RSocketServ, RConnection

#include <in_sock.h>    // KAfInet

#include <es_enum.h>    // TConnectionInfo

#include "cmmdestinationstruct.h"

#include "cmmlistenermanager.h"

#include "cmminstancemapping.h"

#include "cmmcache.h"

#include "cmmdestinationinstance.h"

#include "cmmconnmethodinstance.h"

#include "cmmtransactionhandler.h"

#include "cmmanagerimpl.h"

#include "cmmbearerprioritycache.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "cmmcacheTraces.h"

#endif

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

// Two phased construction.

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

//

CCmmCache* CCmmCache::NewL(

        CCmManagerImpl* aCmManagerImpl,

        CArrayPtrFlat<const CCmPluginBaseEng>* aPlugins )

    {

    OstTraceFunctionEntry0( CCMMCACHE_NEWL_ENTRY );

    CCmmCache* self = CCmmCache::NewLC( aCmManagerImpl, aPlugins );

    CleanupStack::Pop( self );

    OstTraceFunctionExit0( CCMMCACHE_NEWL_EXIT );

    return self;

    }

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

// Two phased construction.

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

//

CCmmCache* CCmmCache::NewLC(

        CCmManagerImpl* aCmManagerImpl,

        CArrayPtrFlat<const CCmPluginBaseEng>* aPlugins )

    {

    OstTraceFunctionEntry0( CCMMCACHE_NEWLC_ENTRY );

    CCmmCache* self = new( ELeave ) CCmmCache( aCmManagerImpl, aPlugins );

    CleanupStack::PushL( self );

    self->ConstructL();

    OstTraceFunctionExit0( CCMMCACHE_NEWLC_EXIT );

    return self;

    }

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

// Destructor.

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

//

CCmmCache::~CCmmCache()

    {

    OstTraceFunctionEntry0( CCMMCACHE_CCMMCACHE_ENTRY );

    delete iBearerPriorityCache;

    delete iListenerManager;

    delete iInstanceMapping;

    iConnMethodArray.ResetAndDestroy();

    iDestinationArray.ResetAndDestroy();

    iDeletedConnMethods.Close();

    iUpdatedConnMethods.Close();

    iUpdatedConnMethods2.Close(); // Does not own contents.

    iUpdatedDestinations.Close();

    iUpdatedDestinations2.Close(); // Does not own contents.

    OstTraceFunctionExit0( CCMMCACHE_CCMMCACHE_EXIT );

    }

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

// Constructor.

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

//

CCmmCache::CCmmCache(

        CCmManagerImpl* aCmManagerImpl,

        CArrayPtrFlat<const CCmPluginBaseEng>* aPlugins )

        :

        iPlugins( aPlugins ),

        iCmManagerImpl( aCmManagerImpl )

    {

    OstTraceFunctionEntry0( DUP1_CCMMCACHE_CCMMCACHE_ENTRY );

    iListenerManager = NULL;

    iInstanceMapping = NULL;

    iTrans = NULL;

    iBearerPriorityCache = NULL;

    iCurrentTemporaryId = KTemporaryIdCounterStart;

    OstTraceFunctionExit0( DUP1_CCMMCACHE_CCMMCACHE_EXIT );

    }

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

// Second phase constructor.

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

//

void CCmmCache::ConstructL()

    {

    OstTraceFunctionEntry0( CCMMCACHE_CONSTRUCTL_ENTRY );

    iTrans = iCmManagerImpl->GetTransactionHandler();

    iBearerPriorityCache = CCmmBearerPriorityCache::NewL(

            iTrans,

            iCmManagerImpl->TableId( ECmmDbBearerPriorityRecord ) );

    iListenerManager = CCmmListenerManager::NewL( this );

    iInstanceMapping = CCmmInstanceMapping::NewL( *this );

    OstTraceFunctionExit0( CCMMCACHE_CONSTRUCTL_EXIT );

    }

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

// Opens a destination with given ID (if not already opened), then copies the

// relevant data to the session instance. Checks that destination ID is valid.

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

//

void CCmmCache::OpenDestinationL(

        CCmmDestinationInstance& aDestinationInstance,

        const TUint32& aDestinationId )

    {

    OstTraceFunctionEntry0( CCMMCACHE_OPENDESTINATIONL_ENTRY );

    if ( !iInstanceMapping->ValidDestinationId( aDestinationId ) )

        {

        User::Leave( KErrNotFound );

        }

    TInt index = FindDestinationFromCache( aDestinationId );

    if ( index == KErrNotFound )

        {

        // Cache does not have a handle open to this destination. A new handle

        // needs to be created first.

        CCmmDestinationStruct* destination = CCmmDestinationStruct::NewLC(

                this,

                iTrans,

                aDestinationId );

        // Now that cache has a handle on this destination, copy the relevant

        // data to the session instance.

        destination->CreateSessionInstanceL( aDestinationInstance );

        iDestinationArray.AppendL( destination );

        CleanupStack::Pop( destination );

        }

    else

        {

        // Cache already has a handle on this destination. Copy the relevant

        // data to the session instance.

        iDestinationArray[index]->CreateSessionInstanceL( aDestinationInstance );

        }

    // Add list of currently contained connection methods.

    iInstanceMapping->GetConnMethodsFromDestinationL(

            aDestinationId,

            aDestinationInstance.iConnMethodItemArray );

    OstTraceFunctionExit0( CCMMCACHE_OPENDESTINATIONL_EXIT );

    }

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

// Refresh the data contained in aDestinationInstance. This means reloading

// the data from database if necessary. After this call the contents of

// aDestinationInstance will reflect the current state in the database. 

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

//

void CCmmCache::RefreshDestinationL( CCmmDestinationInstance& aDestinationInstance )

    {

    OstTraceFunctionEntry0( CCMMCACHE_REFRESHDESTINATIONL_ENTRY );

    TInt index = FindDestinationFromCache( aDestinationInstance.GetId() );

    if ( index == KErrNotFound )

        {

        index = FindNotSavedDestinationFromCacheL( aDestinationInstance.GetDestinationNameL(), 0 );

        if ( index == KErrNotFound )

            {

            User::Leave( KErrNotFound );

            }

        }

    // If this destination is a newly created one that doesn't yet exist in

    // database, just return silently.

    if ( iDestinationArray[index]->GetStatus() == ECmmDestinationStatusNotSaved )

        {

        OstTraceFunctionExit0( CCMMCACHE_REFRESHDESTINATIONL_EXIT );

        return;

        }

    iDestinationArray[index]->RefreshDestinationInstanceL( aDestinationInstance );

    OstTraceFunctionExit0( DUP1_CCMMCACHE_REFRESHDESTINATIONL_EXIT );

    }

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

// Create a new destination into cache (with name and ID) and copy the data

// into session side handle.

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

//

void CCmmCache::CreateDestinationL(

        CCmmDestinationInstance& aDestinationInstance,

        const TDesC& aName,

        const TUint32& aId )

    {

    OstTraceFunctionEntry0( CCMMCACHE_CREATEDESTINATIONL_ENTRY );

    // Create a new destination with given name.

    CCmmDestinationStruct* destination = CCmmDestinationStruct::NewLC( this, iTrans, aName, aId );

    destination->CreateSessionInstanceL( aDestinationInstance );

    iDestinationArray.AppendL( destination );

    CleanupStack::Pop( destination );

    OstTraceFunctionExit0( CCMMCACHE_CREATEDESTINATIONL_EXIT );

    }

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

// Opens a connection method with given ID (if not already opened), then

// creates and passes an instance of it to the caller.

// If aDestinationInstance is not NULL, connection method is opened from

// destination.

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

//

void CCmmCache::OpenConnMethodL(

        CCmmConnMethodInstance& aConnMethodInstance,

        CCmmDestinationInstance* aDestinationInstance,

        const TUint32& aConnMethodId )

    {

    OstTraceFunctionEntry0( CCMMCACHE_OPENCONNMETHODL_ENTRY );

    // Check connection method ID.

    TBool validAttributes( EFalse );

    if ( !aDestinationInstance )

        {

        // Check connection method exists in database.

        validAttributes = iInstanceMapping->ValidConnMethodId( aConnMethodId ); // Embedded destinations not included.

        }

    else

        {

        // Check connection method is inside the destination.

        if ( aDestinationInstance->ValidConnMethodIdInDestinationIncludeEmbedded( aConnMethodId ) )

            {

            // Check connection method (can be embedded destination too) exists in database.

            if ( iInstanceMapping->ValidConnMethodId( aConnMethodId ) ||

                    iInstanceMapping->ValidDestinationId( aConnMethodId ) )

                {

                validAttributes = ETrue;

                }

            }

       }

    if ( !validAttributes )

        {

        User::Leave( KErrNotFound );

        }

    // Create the connection method instance.

    // Check if connection method is already opened in cache.

    TInt index = FindConnMethodFromCache( aConnMethodId );

    if ( index != KErrNotFound )

        {

        // Already open in cache. Copy the connection method data to session

        // instance.

        aConnMethodInstance.CopyDataL( iConnMethodArray[index] ); // Will increase reference counter.

        }

    else

        {

        // Not yet open in cache, open now.

        OpenConnectionMethodInstanceL( aConnMethodInstance, aConnMethodId );

        }

    OstTraceFunctionExit0( CCMMCACHE_OPENCONNMETHODL_EXIT );

    }

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

// Refresh the data contained in aConnMethodInstance. This means reloading the

// data from database if necessary. After this call the contents of

// aConnMethodInstance will reflect the current state in the database. 

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

//

void CCmmCache::RefreshConnMethodL( CCmmConnMethodInstance& aConnMethodInstance )

    {

    OstTraceFunctionEntry0( CCMMCACHE_REFRESHCONNMETHODL_ENTRY );

    //TODO, what to do with embedded?

    TInt index = FindConnMethodFromCache( aConnMethodInstance.GetId() );

    if ( index == KErrNotFound )

        {

        User::Leave( KErrNotFound );

        }

    // If this connection method is a newly created one that doesn't yet exist

    // in database, just return silently.

    if ( iConnMethodArray[index]->GetStatus() == ECmmConnMethodStatusNotSaved )

        {

        OstTraceFunctionExit0( CCMMCACHE_REFRESHCONNMETHODL_EXIT );

        return;

        }

    iConnMethodArray[index]->RefreshConnMethodInstanceL( aConnMethodInstance );

    OstTraceFunctionExit0( DUP1_CCMMCACHE_REFRESHCONNMETHODL_EXIT );

    }

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

// Creates a new connection method (not embedded destinations) into database

// with the given bearer type and optionally ID, then creates and passes an

// instance of it to the caller.

// If destination instance is provided (not NULL), connection method is

// created in that destination.

// If connection method ID is provided, it's availability is verified.

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

//

void CCmmCache::CreateConnMethodL(

        CCmmConnMethodInstance& aConnMethodInstance,

        CCmmDestinationInstance* aDestinationInstance,

        const TUint32& aBearerType,

        const TUint32& aConnMethodId )

    {

    OstTraceFunctionEntry0( CCMMCACHE_CREATECONNMETHODL_ENTRY );

    // Check that the bearer type is not embedded destination.

    if ( aBearerType == KUidEmbeddedDestination )

        {

        User::Leave( KErrArgument );

        }

    TUint32 connMethodId( aConnMethodId );

    if ( aConnMethodId )

        {

        // Check if a connection method with given ID exists (or is already

        // created but not saved).

        if ( iInstanceMapping->ValidConnMethodId( aConnMethodId ) ||

                ConnMethodOpenWithId( aConnMethodId ) )

            {

            User::Leave( KErrAlreadyExists );

            }

        }

    else

        {

        // Use a temporary ID until a real one is received from database.

        connMethodId = NextFreeTemporaryId();

        }

    // Check bearer type support and create plugin instance.

    CCmPluginBaseEng* plugin = NULL;

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

        {

        if ( ( *iPlugins )[i]->GetBearerInfoIntL( CMManager::ECmBearerType ) == aBearerType )

            {

            TCmPluginInitParam pluginParams( Session() );

            plugin = ( *iPlugins )[i]->CreateInstanceL( pluginParams );

            CleanupStack::PushL( plugin );

            plugin->CreateNewL( aConnMethodId ); // Use aConnMethodId here, so ID is either a real ID or 0.

            break;

            }

        }

    if ( !plugin )

        {

        User::Leave( KErrArgument );

        }

    // Store the connection method into cache.

    CCmmConnMethodStruct* connMethodStruct = CCmmConnMethodStruct::NewLC( connMethodId ); // Use connMethodId here, so ID is either a real ID or a temporary ID.

    connMethodStruct->SetPlugin( plugin, aBearerType, ECmmConnMethodStatusNotSaved );

    iConnMethodArray.AppendL( connMethodStruct );

    CleanupStack::Pop( connMethodStruct );

    CleanupStack::Pop( plugin ); //TODO, pop after SetPlugin()-call?

    // Copy the connection method data to session instance.

    aConnMethodInstance.CopyDataL( connMethodStruct ); // Will increase reference counter.

    if ( aDestinationInstance )

        {

        // Add connection method to destination.

        aDestinationInstance->AddConnMethodL( aConnMethodInstance );

        }

    OstTraceFunctionExit0( CCMMCACHE_CREATECONNMETHODL_EXIT );

    }

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

// Creates a new connection method into cache as a copy of an existing

// connection method (exists in cache, not necessarily in database), and opens

// a client side handle to it. The new connection method will get a new ID when

// updated to database.

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

//

void CCmmCache::CreateCopyOfConnMethodL(

        CCmmConnMethodInstance& aNewConnMethodInstance,

        CCmmConnMethodInstance& aConnMethodInstance )

    {

    OstTraceFunctionEntry0( CCMMCACHE_CREATECOPYOFCONNMETHODL_ENTRY );

    // Check bearer type support and create plugin instance.

    TInt index = FindConnMethodFromCache( aConnMethodInstance.GetId() );

    if ( index == KErrNotFound )

        {

        User::Leave( index );

        }

    CCmPluginBaseEng* plugin = iConnMethodArray[index]->GetPlugin();

    if ( !plugin )

        {

        User::Leave( KErrNotFound );

        }

    CCmPluginBaseEng* pluginCopy = plugin->CreateCopyL( aConnMethodInstance.GetPluginDataInstance() );

    CleanupStack::PushL( pluginCopy );

    // Store the connection method into cache.

    CCmmConnMethodStruct* connMethodStruct = CCmmConnMethodStruct::NewLC( NextFreeTemporaryId() );

    connMethodStruct->SetPlugin( pluginCopy, aConnMethodInstance.GetBearerType(), ECmmConnMethodStatusNotSaved );

    iConnMethodArray.AppendL( connMethodStruct );

    CleanupStack::Pop( connMethodStruct );

    CleanupStack::Pop( pluginCopy ); //TODO, pop after SetPlugin()-call?

    // Copy the connection method data to session instance.

    aNewConnMethodInstance.CopyDataL( connMethodStruct ); // Will increase reference counter.

    OstTraceFunctionExit0( CCMMCACHE_CREATECOPYOFCONNMETHODL_EXIT );

    }

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

// Re-loads a destination record if needed and copies the latest version to

// the session instance given as parameter.

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

//

void CCmmCache::LoadDestinationRecordL(

        CCmmDestinationInstance& aDestinationInstance,

        TCmmDbRecords aDestRecordType )

    {

    OstTraceFunctionEntry0( CCMMCACHE_LOADDESTINATIONRECORDL_ENTRY );

    TUint32 id = aDestinationInstance.GetId();

    // If ID is not in the valid range, it means the destination is a newly

    // created one, and doesn't yet exist in database. Thus, record data exists

    // only in session side and can't be loaded from cache. So this is an error.

    if ( id >= KTemporaryIdCounterStart )

        {

        User::Leave( KErrCorrupt );

        }

    TInt index = FindDestinationFromCache( id );

    if ( index < 0 )

        {

        User::Leave( index );

        }

    iDestinationArray[index]->LoadRecordL( aDestinationInstance, aDestRecordType );

    OstTraceFunctionExit0( CCMMCACHE_LOADDESTINATIONRECORDL_EXIT );

    }

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

// Saves the modifications in aDestinationInstance into the database. Also all

// connection methods inside this destination are updated (including any

// embedded destination).

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

//

void CCmmCache::UpdateDestinationL( CCmmDestinationInstance& aDestinationInstance )

    {

    OstTraceFunctionEntry0( CCMMCACHE_UPDATEDESTINATIONL_ENTRY );

    // Arrays to temporarily store information of updated destinations and

    // connection methods. Used to update status and ID information after

    // successful commit to database.

    if ( iTrans->GetReferenceCount() == 0 )

        {

        iDeletedConnMethods.Reset();

        iUpdatedConnMethods.Reset();

        iUpdatedConnMethods2.Reset();

        iUpdatedDestinations.Reset();

        iUpdatedDestinations2.Reset();

        }

    TInt index = FindDestinationFromCache( aDestinationInstance.GetId() );

    if ( index < 0 )

        {

        User::Leave( index );

        }

    iTrans->OpenTransactionLC();

    // Check that the connection methods marked for deletion can be deleted.

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

        {

        TUint32 id = aDestinationInstance.iConnMethodsToBeDeleted[i];