/*

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

* Cache side object representing a destination.

*

*/

#include <datamobilitycommsdattypes.h>

#include <cmpluginembdestinationdef.h>

#include <in_sock.h> // KAfInet

#include "cmmdestinationstruct.h"

#include "cmmtransactionhandler.h"

#include "cmmdestinationinstance.h"

#include "cmmcache.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "cmmdestinationstructTraces.h"

#endif

const TUint KDefaultTierManagerTagId = KAfInet;

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

// Two phased construction.

// Opens a destination from database based on ID.

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

//

CCmmDestinationStruct* CCmmDestinationStruct::NewL(

        CCmmCache* aCache,

        CCmmTransactionHandler* aTransactionHandler,

        const TUint32& aDestinationId )

    {

    OstTraceFunctionEntry0( CCMMDESTINATIONSTRUCT_NEWL_ENTRY );

    CCmmDestinationStruct* self = CCmmDestinationStruct::NewLC( aCache, aTransactionHandler, aDestinationId );

    CleanupStack::Pop( self );

    OstTraceFunctionExit0( CCMMDESTINATIONSTRUCT_NEWL_EXIT );

    return self;

    }

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

// Two phased construction.

// Creates a new destination with name and ID (optional).

// If ID is 0, a free ID will be used when destination is saved to database.

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

//

CCmmDestinationStruct* CCmmDestinationStruct::NewL(

        CCmmCache* aCache,

        CCmmTransactionHandler* aTransactionHandler,

        const TDesC& aName,

        const TUint32& aDestinationId )

    {

    OstTraceFunctionEntry0( DUP1_CCMMDESTINATIONSTRUCT_NEWL_ENTRY );

    CCmmDestinationStruct* self = CCmmDestinationStruct::NewLC( aCache, aTransactionHandler, aName, aDestinationId );

    CleanupStack::Pop( self );

    OstTraceFunctionExit0( DUP1_CCMMDESTINATIONSTRUCT_NEWL_EXIT );

    return self;

    }

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

// Two phased construction.

// Opens a destination from database based on ID.

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

//

CCmmDestinationStruct* CCmmDestinationStruct::NewLC(

        CCmmCache* aCache,

        CCmmTransactionHandler* aTransactionHandler,

        const TUint32& aDestinationId )

    {

    OstTraceFunctionEntry0( CCMMDESTINATIONSTRUCT_NEWLC_ENTRY );

    CCmmDestinationStruct* self = new( ELeave ) CCmmDestinationStruct( aCache, aTransactionHandler );

    CleanupStack::PushL( self );

    self->ConstructL( aDestinationId );

    OstTraceFunctionExit0( CCMMDESTINATIONSTRUCT_NEWLC_EXIT );

    return self;

    }

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

// Two phased construction.

// Creates a new destination with name and ID (optional).

// If ID is 0, a free ID will be used when destination is saved to database.

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

//

CCmmDestinationStruct* CCmmDestinationStruct::NewLC(

        CCmmCache* aCache,

        CCmmTransactionHandler* aTransactionHandler,

        const TDesC& aName,

        const TUint32& aDestinationId )

    {

    OstTraceFunctionEntry0( DUP1_CCMMDESTINATIONSTRUCT_NEWLC_ENTRY );

    CCmmDestinationStruct* self = new( ELeave ) CCmmDestinationStruct( aCache, aTransactionHandler );

    CleanupStack::PushL( self );

    self->ConstructL( aName, aDestinationId );

    OstTraceFunctionExit0( DUP1_CCMMDESTINATIONSTRUCT_NEWLC_EXIT );

    return self;

    }

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

// Destructor.

// Cancels any active requests.

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

//

CCmmDestinationStruct::~CCmmDestinationStruct()

    {

    OstTraceFunctionEntry0( CCMMDESTINATIONSTRUCT_CCMMDESTINATIONSTRUCT_ENTRY );

    if ( iReferenceCounter != 0 )

        {

        ASSERT(0); // Error.

        }

    delete iNetworkRecord;

    delete iDestApRecord;

    delete iMetadataRecord;

    delete iName;

    OstTraceFunctionExit0( CCMMDESTINATIONSTRUCT_CCMMDESTINATIONSTRUCT_EXIT );

    }

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

// Constructor.

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

//

CCmmDestinationStruct::CCmmDestinationStruct(

        CCmmCache* aCache,

        CCmmTransactionHandler* aTransactionHandler )

        :

        iCache( aCache ),

        iTransactionHandler( aTransactionHandler )

    {

    OstTraceFunctionEntry0( DUP1_CCMMDESTINATIONSTRUCT_CCMMDESTINATIONSTRUCT_ENTRY );

    iDestApRecord = NULL;

    iNetworkRecord = NULL;

    iMetadataRecord = NULL;

    iDestApRecordStatus = ECmmRecordStatusBlank;

    iNetworkRecordStatus = ECmmRecordStatusBlank;

    iMetadataRecordStatus = ECmmRecordStatusBlank;

    iReferenceCounter = 0;

    iStatus = ECmmDestinationStatusNotSaved;

    iId = 0;

    iName = NULL;

    OstTraceFunctionExit0( DUP1_CCMMDESTINATIONSTRUCT_CCMMDESTINATIONSTRUCT_EXIT );

    }

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

// Second phase constructor.

// Opens an existing destination based on ID.

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

//

void CCmmDestinationStruct::ConstructL( const TUint32& aDestinationId )

    {

    OstTraceFunctionEntry0( CCMMDESTINATIONSTRUCT_CONSTRUCTL_ENTRY );

    // Check ID is in valid range.

    if ( aDestinationId <= KCmDefaultDestinationAPTagId || aDestinationId >= KCmMaxDestinationAPTagId )

        {

        User::Leave( KErrArgument );

        }

    iId = aDestinationId;

    iDestApRecord = static_cast<CommsDat::CCDAccessPointRecord*>(

            CommsDat::CCDRecordBase::RecordFactoryL( CommsDat::KCDTIdAccessPointRecord ) );

    iNetworkRecord = static_cast<CommsDat::CCDNetworkRecord*>(

            CommsDat::CCDRecordBase::RecordFactoryL( CommsDat::KCDTIdNetworkRecord ) );

    iMetadataRecord = new( ELeave ) CCDSNAPMetadataRecord(

            iCache->TableId( ECmmDestMetadataRecord ) );

    // Load access point record.

    iDestApRecord->iRecordTag = iId;

    if ( iDestApRecord->FindL( iTransactionHandler->Session() ) )

        {

        iDestApRecord->LoadL( iTransactionHandler->Session() );

        }

    else

        {

        User::Leave( KErrNotFound );

        }

    iDestApRecordStatus = ECmmRecordStatusLoaded;

    // Load network record.

    iNetworkRecord->SetRecordId( iDestApRecord->iCustomSelectionPolicy );

    iNetworkRecord->LoadL( iTransactionHandler->Session() );

    iNetworkRecordStatus = ECmmRecordStatusLoaded;

    // Load metadata record.

    iMetadataRecord->iSNAP = iId;

    if ( !iMetadataRecord->FindL( iTransactionHandler->Session() ) )

        {

        // Not found -> fill in with default values.

        iMetadataRecord->iSNAP = iId;

        iMetadataRecord->iMetadata = 0;

        iMetadataRecord->SetRecordId( KCDNewRecordRequest );

        iMetadataRecordStatus = ECmmRecordStatusUnsaved;

        }

    else

        {

        iMetadataRecord->LoadL( iTransactionHandler->Session() );

        iMetadataRecordStatus = ECmmRecordStatusLoaded;

        }

    SetStatus( ECmmDestinationStatusValid );

    OstTraceFunctionExit0( CCMMDESTINATIONSTRUCT_CONSTRUCTL_EXIT );

    }

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

// Second phase constructor.

// Creates a new destination. With name and optionally also with ID.

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

//

void CCmmDestinationStruct::ConstructL( const TDesC& aName, const TUint32& aDestinationId )

    {

    OstTraceFunctionEntry0( DUP1_CCMMDESTINATIONSTRUCT_CONSTRUCTL_ENTRY );

    SetStatus( ECmmDestinationStatusNotSaved );

    iId = aDestinationId;

    iName = aName.AllocL();

    iDestApRecord = static_cast<CommsDat::CCDAccessPointRecord*>(

            CommsDat::CCDRecordBase::RecordFactoryL( CommsDat::KCDTIdAccessPointRecord ) );

    iNetworkRecord = static_cast<CommsDat::CCDNetworkRecord*>(

            CommsDat::CCDRecordBase::RecordFactoryL( CommsDat::KCDTIdNetworkRecord ) );

    iMetadataRecord = new( ELeave ) CCDSNAPMetadataRecord(

            iCache->TableId( ECmmDestMetadataRecord ) );

    if ( aDestinationId >= KTemporaryIdCounterStart )

        {

        // Get a real ID from database during UpdateL().

        iNetworkRecord->SetRecordId( KCDNewRecordRequest );

        iDestApRecord->iRecordTag = 0;

        iDestApRecord->iCustomSelectionPolicy = 0;

        // Access Point record tag ID and custom selection policy value need to

        // be set during UpdateL(), when network record's record ID is known.

        // Also metadata record SNAP ID needs to be set.

        iMetadataRecord->iSNAP = 0;

        }

    else

        {

        // Client provided an actual ID.

        iNetworkRecord->SetRecordId( aDestinationId - KCmDefaultDestinationAPTagId );

        iDestApRecord->iRecordTag = aDestinationId;

        iDestApRecord->iCustomSelectionPolicy = ( aDestinationId - KCmDefaultDestinationAPTagId );

        iMetadataRecord->iSNAP = aDestinationId;

        }

    iDestApRecord->SetRecordId( KCDNewRecordRequest );

    iMetadataRecord->iMetadata = 0;

    iMetadataRecord->SetRecordId( KCDNewRecordRequest );

    iNetworkRecord->iRecordName.SetL( aName );

    iDestApRecord->iRecordName.SetL( aName );

    InitializeDestApRecordL();

    iDestApRecordStatus = ECmmRecordStatusUnsaved;

    iNetworkRecordStatus = ECmmRecordStatusUnsaved;

    iMetadataRecordStatus = ECmmRecordStatusUnsaved;

    OstTraceFunctionExit0( DUP1_CCMMDESTINATIONSTRUCT_CONSTRUCTL_EXIT );

    }

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

// Set the destination ID.

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

//

void CCmmDestinationStruct::SetId( const TUint32& aId )

    {

    iId = aId;

    }

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

// Get the destination ID.

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

//

TUint32 CCmmDestinationStruct::GetId() const

    {

    return iId;

    }

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

// Get the destination ID from network record. To get a valid ID, this must be

// called only during or after a call to UpdateL().

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

//

TUint32 CCmmDestinationStruct::GetRealId() const

    {

    TUint32 id( iId );

    if ( iNetworkRecord )

        {

        id = ( TUint32 )iNetworkRecord->RecordId() + KCmDefaultDestinationAPTagId;

        }

    return id;

    }

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

// Get the destination name.

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

//

TDesC& CCmmDestinationStruct::GetDestinationNameL()

    {

    OstTraceFunctionEntry0( CCMMDESTINATIONSTRUCT_GETDESTINATIONNAMEL_ENTRY );

    // No network record exists if destination has not been saved yet.

    if ( iStatus == ECmmDestinationStatusNotSaved && iName )

        {

        OstTraceFunctionExit0( CCMMDESTINATIONSTRUCT_GETDESTINATIONNAMEL_EXIT );

        return *iName;

        }

    if ( iNetworkRecord )

        {

        return iNetworkRecord->iRecordName.GetL();

        }

    User::Leave( KErrCorrupt );

    OstTraceFunctionExit0( DUP1_CCMMDESTINATIONSTRUCT_GETDESTINATIONNAMEL_EXIT );

    return *iName;

    }

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

// Gets the current status of this destination struct.

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

//

TCmmDestinationStatus CCmmDestinationStruct::GetStatus() const

    {

    return iStatus;

    }

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

// Get the current reference count.

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

//

TInt CCmmDestinationStruct::GetReferenceCount() const

    {

    return iReferenceCounter;

    }

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

// Set the current status of this destination.

// ECmmDestinationStatusValid: Destination exists in database.

// ECmmDestinationStatusNotSaved: Destination does NOT exist in database yet.

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

//

void CCmmDestinationStruct::SetStatus( const TCmmDestinationStatus& aStatus )

    {

    OstTraceFunctionEntry0( CCMMDESTINATIONSTRUCT_SETSTATUS_ENTRY );

    switch ( aStatus )

        {

        case ECmmDestinationStatusValid:

            {

            if ( iStatus == ECmmDestinationStatusNotSaved )

                {

                delete iName;

                iName = NULL;

                }

            }

            // Fallthrough intended.

        case ECmmDestinationStatusNotSaved:

        case ECmmDestinationStatusToBeDeleted:

            {

            // Set the status.

            iStatus = aStatus;

            }

            break;

        default:

            ASSERT( 0 ); // Error, invalid status.

            break;

        }

    OstTraceFunctionExit0( CCMMDESTINATIONSTRUCT_SETSTATUS_EXIT );

    }

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

// Set the record status for all records.

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

//

void CCmmDestinationStruct::SetStatusForAllRecords( const TCmmRecordStatus& aStatus )

    {

    OstTraceFunctionEntry0( CCMMDESTINATIONSTRUCT_SETSTATUSFORALLRECORDS_ENTRY );

    iDestApRecordStatus = aStatus;

    iNetworkRecordStatus = aStatus;

    iMetadataRecordStatus = aStatus;

    OstTraceFunctionExit0( CCMMDESTINATIONSTRUCT_SETSTATUSFORALLRECORDS_EXIT );

    }

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

// Copies the data for this destination to a session instance and increments

// the reference counter by one.

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

//

void CCmmDestinationStruct::CreateSessionInstanceL(

        CCmmDestinationInstance& aDestinationInstance )

    {

    OstTraceFunctionEntry0( CCMMDESTINATIONSTRUCT_CREATESESSIONINSTANCEL_ENTRY );

    // This should work according to status. If status is valid, this

    // destination exists in commsdat, and other sessions can also open a handle

    // to it. Make copies of the records to give to session instance.

    //

    // If the status is unsaved, then this is a new destination that hasn't

    // been saved to commsdat yet. Thus no other session can open a handle to it

    // until it is saved with a call to UpdateL().

    // For a non-valid destination, to save memory, transfer the ownership of

    // record pointers straight to the session and mark the cache pointers as

    // NULL. When update is called, copy the records into the cache also.

    //

    switch ( iStatus ) //TODO, add missing status values

        {

        case ECmmDestinationStatusNotSaved:

            {

            // Transfer ownership of table records to session. Mark local pointers to NULL.

            aDestinationInstance.SetRecordPointer( ECmmDestApRecord, iDestApRecord ); // iDestApRecord ownership is transfered.

            aDestinationInstance.SetRecordPointer( ECmmDestNetworkRecord, iNetworkRecord ); // iNetworkRecord ownership is transfered.

            aDestinationInstance.SetRecordPointer( ECmmDestMetadataRecord, iMetadataRecord ); // iMetadataRecord ownership is transfered.

            iDestApRecord = NULL;

            iNetworkRecord = NULL;

            iMetadataRecord = NULL;

            iDestApRecordStatus = ECmmRecordStatusBlank;

            iNetworkRecordStatus = ECmmRecordStatusBlank;

            iMetadataRecordStatus = ECmmRecordStatusBlank;

            aDestinationInstance.SetId( iId );

            aDestinationInstance.SetStatus( ECmmDestinationStatusChanged );

            }

            break;

        case ECmmDestinationStatusValid:

            {

            // Reload table records if needed, make copies and transfer those to session.

            LoadRecordL( aDestinationInstance, ECmmDestApRecord );

            LoadRecordL( aDestinationInstance, ECmmDestNetworkRecord );

            LoadRecordL( aDestinationInstance, ECmmDestMetadataRecord );

            aDestinationInstance.SetId( iId );

            aDestinationInstance.SetStatus( ECmmDestinationStatusValid );

            }

            break;

        default:

            User::Leave( KErrCorrupt ); // Invalid status.

            break;

        }

    // A session handle has been made, increment reference counter.

    iReferenceCounter++;

    OstTraceFunctionExit0( CCMMDESTINATIONSTRUCT_CREATESESSIONINSTANCEL_EXIT );

    }

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

// TODO

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

//

void CCmmDestinationStruct::RefreshDestinationInstanceL(

        CCmmDestinationInstance& aDestinationInstance )

    {

    OstTraceFunctionEntry0( CCMMDESTINATIONSTRUCT_REFRESHSESSIONINSTANCEL_ENTRY );

    switch ( iStatus )

        {

        case ECmmDestinationStatusValid:

        case ECmmDestinationStatusToBeDeleted:

            {

            // Reload table records if needed, make copies and transfer those to session.

            LoadRecordL( aDestinationInstance, ECmmDestApRecord );

            LoadRecordL( aDestinationInstance, ECmmDestNetworkRecord );

            LoadRecordL( aDestinationInstance, ECmmDestMetadataRecord );

            }

            break;

        case ECmmDestinationStatusNotSaved: // This was checked before.

        case ECmmDestinationStatusChanged:

        default:

            User::Leave( KErrCorrupt ); // Invalid status.

            break;

        }

    // Add list of currently contained connection methods.

    iCache->GetConnMethodsFromDestinationL(

            aDestinationInstance.GetId(),

            aDestinationInstance.iConnMethodItemArray );

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

    aDestinationInstance.UpdateSuccessful();

    OstTraceFunctionExit0( CCMMDESTINATIONSTRUCT_REFRESHSESSIONINSTANCEL_EXIT );

    }

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

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

// the session instance given as parameter.

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

//

void CCmmDestinationStruct::LoadRecordL(

        CCmmDestinationInstance& aDestinationInstance,

        TCmmDbRecords aRecordType )

    {

    OstTraceFunctionEntry0( CCMMDESTINATIONSTRUCT_LOADRECORDL_ENTRY );

    if ( iStatus != ECmmDestinationStatusValid && iStatus != ECmmDestinationStatusToBeDeleted )

        {

        // Destination must exist in database to be able to load any records.