/*

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

    iSnapTableId = 0;

    iSnapMetadataTableId = 0;

    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 );

    // Create CommsDat listeners to detect changes to the database from external sources.

    RArray<TUint32> tableIdArray;

    CleanupClosePushL( tableIdArray );

    iSnapTableId = iCmManagerImpl->TableId( ECmmDbSnapRecord );

    iSnapMetadataTableId = iCmManagerImpl->TableId( ECmmDestMetadataRecord );

    // Instancemapping needs notifications on following tables.

    tableIdArray.Append( CommsDat::KCDTIdIAPRecord );

    tableIdArray.Append( CommsDat::KCDTIdVPNServiceRecord );

    tableIdArray.Append( iSnapTableId );

    tableIdArray.Append( iSnapMetadataTableId );

    // Destinations need notifications on following tables.

    tableIdArray.Append( CommsDat::KCDTIdNetworkRecord );

    tableIdArray.Append( CommsDat::KCDTIdAccessPointRecord );

    // Destination metadata table was already added.

    // Connection methods need notifications on following tables.

    TInt pluginCount( iPlugins->Count() );

    if ( pluginCount )

        {

        ( *iPlugins )[0]->GetGenericTableIdsToBeObservedL( tableIdArray );

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

            {

            ( *iPlugins )[i]->GetBearerTableIdsToBeObservedL( tableIdArray );

            }

        }

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

        {

        iListenerManager->AddListenerL( tableIdArray[i] );

        }

    CleanupStack::PopAndDestroy( &tableIdArray );

    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->CreateDestinationInstanceL( 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]->CreateDestinationInstanceL( 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->CreateDestinationInstanceL( 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.

        // Embedded destinations not included.

        validAttributes = iInstanceMapping->ValidConnMethodId( aConnMethodId );

        }

    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 )

        {

        // Update data from commsdat if necessary.

        if ( iConnMethodArray[index]->GetRecordStatus() == ECmmRecordStatusExpired )

            {

            iConnMethodArray[index]->ReloadPluginDataIfNeededL();

            // CopyDataL() will set the internal state of aConnMethodInstance.

            }

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

        // instance.

        // Will increase reference counter.

        aConnMethodInstance.CopyDataL( iConnMethodArray[index] );

        }

    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 );

    // If embedded destination --> refresh through destination API.

    if ( aConnMethodInstance.IsEmbeddedDestination() )

        {

        return;

        }

    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]->ReloadPluginDataIfNeededL();

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

            || iConnMethodArray[index]->GetStatus() == ECmmConnMethodStatusToBeDeleted )

        {

        iConnMethodArray[index]->GetPlugin()->GetPluginDataL( 

                aConnMethodInstance.GetPluginDataInstance() );

        }

    // Internal state need to be set to the same state as after a successfull update.

    aConnMethodInstance.UpdateSuccessful();

    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 )

        {

        }

    // Store the connection method into cache.

    // Use connMethodId here, so ID is either a real ID or a temporary ID.

    CCmmConnMethodStruct* connMethodStruct = CCmmConnMethodStruct::NewL( connMethodId );

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

    CleanupStack::Pop( plugin );

    CleanupStack::PushL( connMethodStruct );

    iConnMethodArray.AppendL( connMethodStruct );

    CleanupStack::Pop( connMethodStruct );

    // 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 );