/*

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

* Session side object representing a destination.

*

*/

#include <cmpluginbaseeng.h>

#include <datamobilitycommsdattypes.h>

#include <cmpluginembdestinationdef.h>

#include "cmmdestinationinstance.h"

#include "cmmsession.h"

#include "cmmcache.h"

#include "cmmconnmethodinstance.h"

#include "cmmconnmethoditem.h"

#include "cmmanagertextresolver.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "cmmdestinationinstanceTraces.h"

#endif

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

// Two phased construction.

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

//

CCmmDestinationInstance* CCmmDestinationInstance::NewL( CCmmSession* aCmmSession, CCmmCache* aCache )

    {

    OstTraceFunctionEntry0( CCMMDESTINATIONINSTANCE_NEWL_ENTRY );

    CCmmDestinationInstance* self = CCmmDestinationInstance::NewLC( aCmmSession, aCache );

    CleanupStack::Pop( self );

    OstTraceFunctionExit0( CCMMDESTINATIONINSTANCE_NEWL_EXIT );

    return self;

    }

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

// Two phased construction.

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

//

CCmmDestinationInstance* CCmmDestinationInstance::NewLC( CCmmSession* aCmmSession, CCmmCache* aCache )

    {

    OstTraceFunctionEntry0( CCMMDESTINATIONINSTANCE_NEWLC_ENTRY );

    CCmmDestinationInstance* self = new( ELeave ) CCmmDestinationInstance( aCmmSession, aCache );

    CleanupClosePushL( *self );

    self->ConstructL();

    OstTraceFunctionExit0( CCMMDESTINATIONINSTANCE_NEWLC_EXIT );

    return self;

    }

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

// Destructor.

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

//

CCmmDestinationInstance::~CCmmDestinationInstance()

    {

    OstTraceFunctionEntry0( CCMMDESTINATIONINSTANCE_CCMMDESTINATIONINSTANCE_ENTRY );

    // Tell cache this handle is beeing closed. Cache will update it's own

    // bookkeeping accordingly.

    if ( iCache )

        {

        iCache->CloseDestination( *this );

        }

    delete iNetworkRecord;

    delete iDestApRecord;

    delete iMetadataRecord;

    iConnMethodItemArray.Close();

    iConnMethodsToBeDeleted.Close();

    OstTraceFunctionExit0( CCMMDESTINATIONINSTANCE_CCMMDESTINATIONINSTANCE_EXIT );

    }

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

// Constructor.

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

//

CCmmDestinationInstance::CCmmDestinationInstance(

        CCmmSession* aCmmSession,

        CCmmCache* aCache )

        :

        iCmmSession( aCmmSession ),

        iCache( aCache )

    {

    OstTraceFunctionEntry0( DUP1_CCMMDESTINATIONINSTANCE_CCMMDESTINATIONINSTANCE_ENTRY );

    iNetworkRecord = NULL;

    iDestApRecord = NULL;

    iMetadataRecord = NULL;

    iNetworkRecordStatus = ECmmRecordStatusBlank;

    iDestApRecordStatus = ECmmRecordStatusBlank;

    iMetadataRecordStatus = ECmmRecordStatusBlank;

    iStatus = ECmmDestinationStatusChanged;

    iId = 0;

    iHandle = 0;

    iProtectionChanged = EFalse;

    iLastProtectionLevel = CMManager::EProtLevel0;

    iCurrentProtectionLevel = CMManager::EProtLevel0;

    OstTraceFunctionExit0( DUP1_CCMMDESTINATIONINSTANCE_CCMMDESTINATIONINSTANCE_EXIT );

    }

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

// Second phase constructor.

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

//

void CCmmDestinationInstance::ConstructL()

    {

    OstTraceFunctionEntry0( CCMMDESTINATIONINSTANCE_CONSTRUCTL_ENTRY );

    OstTraceFunctionExit0( CCMMDESTINATIONINSTANCE_CONSTRUCTL_EXIT );

    }

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

// Set the destination ID.

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

//

void CCmmDestinationInstance::SetId( const TUint32& aId )

    {

    OstTraceFunctionEntry0( CCMMDESTINATIONINSTANCE_SETID_ENTRY );

    iId = aId;

    // If this is the real ID (not the temporary ID of a new unsaved destination),

    // write it also into network record.

    if ( aId > KCmmDestIdIntervalMin && aId < KCmmDestIdIntervalMax )

        {

        iNetworkRecord->SetRecordId( aId - KCmDefaultDestinationAPTagId );

        iDestApRecord->iRecordTag = aId;

        iDestApRecord->iCustomSelectionPolicy = ( aId - KCmDefaultDestinationAPTagId );

        iMetadataRecord->iSNAP = aId;

        }

    OstTraceFunctionExit0( CCMMDESTINATIONINSTANCE_SETID_EXIT );

    }

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

// Get the destination ID.

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

//

TUint32 CCmmDestinationInstance::GetId() const

    {

    OstTraceFunctionEntry0( CCMMDESTINATIONINSTANCE_GETID_ENTRY );

    OstTraceFunctionExit0( CCMMDESTINATIONINSTANCE_GETID_EXIT );

    return iId;

    }

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

// Set the current status of this destination.

// ECmmDestinationStatusValid: Contents in sync with database.

// ECmmDestinationStatusChanged: Contents differ from database contents.

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

//

void CCmmDestinationInstance::SetStatus( const TCmmDestinationStatus& aStatus )

    {

    OstTraceFunctionEntry0( CCMMDESTINATIONINSTANCE_SETSTATUS_ENTRY );

    switch ( aStatus )

        {

        // Fallthrough intended

        case ECmmDestinationStatusValid:

        case ECmmDestinationStatusChanged:

            iStatus = aStatus;

            break;

        default:

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

            break;

        }

    OstTraceFunctionExit0( CCMMDESTINATIONINSTANCE_SETSTATUS_EXIT );

    }

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

// Gets the current status of this destination instance.

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

//

TCmmDestinationStatus CCmmDestinationInstance::GetStatus() const

    {

    OstTraceFunctionEntry0( CCMMDESTINATIONINSTANCE_GETSTATUS_ENTRY );

    OstTraceFunctionExit0( CCMMDESTINATIONINSTANCE_GETSTATUS_EXIT );

    return iStatus;

    }

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

// Get handle ID.

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

//

TInt CCmmDestinationInstance::GetHandle() const

    {

    return iHandle;

    }

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

// Set handle ID.

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

//

void CCmmDestinationInstance::SetHandle( const TInt& aHandle )

    {

    iHandle = aHandle;

    }

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

// Set the record status for all records.

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

//

void CCmmDestinationInstance::SetStatusForAllRecords( const TCmmRecordStatus& aStatus )

    {

    OstTraceFunctionEntry0( CCMMDESTINATIONINSTANCE_SETSTATUSFORALLRECORDS_ENTRY );

    iDestApRecordStatus = aStatus;

    iNetworkRecordStatus = aStatus;

    iMetadataRecordStatus = aStatus;

    OstTraceFunctionExit0( CCMMDESTINATIONINSTANCE_SETSTATUSFORALLRECORDS_EXIT );

    }

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

// Get the destination element ID.

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

//

TUint32 CCmmDestinationInstance::GetElementIdL()

    {

    OstTraceFunctionEntry0( CCMMDESTINATIONINSTANCE_GETELEMENTIDL_ENTRY );

    RefreshRecordL( ECmmDestNetworkRecord );

    if ( !iNetworkRecord )

        {

        User::Leave( KErrCorrupt );

        }

    OstTraceFunctionExit0( CCMMDESTINATIONINSTANCE_GETELEMENTIDL_EXIT );

    return iNetworkRecord->ElementId() & KCDMaskShowField;

    }

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

// Get the destination access point record's record tag (destination ID).

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

//

TUint32 CCmmDestinationInstance::GetRecordTagFromApRecordL()

    {

    OstTraceFunctionEntry0( CCMMDESTINATIONINSTANCE_GETRECORDTAGFROMAPRECORDL_ENTRY );

    RefreshRecordL( ECmmDestApRecord );

    if ( !iDestApRecord )

        {

        User::Leave( KErrCorrupt );

        }

    OstTraceFunctionExit0( CCMMDESTINATIONINSTANCE_GETRECORDTAGFROMAPRECORDL_EXIT );

    return iDestApRecord->iRecordTag;

    }

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

// Sets a record pointer to the one given as parameter, Ownership is

// transfered. Also deletes the previous pointer and sets the record status

// to 'ECmmRecordStatusLoaded'.

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

//

TInt CCmmDestinationInstance::SetRecordPointer(

        const TCmmDbRecords& aDestRecord,

        CommsDat::CCDRecordBase* aRecordPointer )

    {

    OstTraceFunctionEntry0( CCMMDESTINATIONINSTANCE_SETRECORDPOINTER_ENTRY );

    TInt ret( KErrNone );

    switch ( aDestRecord )

        {

        case ECmmDestNetworkRecord:

            {

            delete iNetworkRecord;

            iNetworkRecord = static_cast<CommsDat::CCDNetworkRecord*>( aRecordPointer );

            iNetworkRecordStatus = ECmmRecordStatusLoaded;

            }

            break;

        case ECmmDestApRecord:

            {

            delete iDestApRecord;

            iDestApRecord = static_cast<CommsDat::CCDAccessPointRecord*>( aRecordPointer );

            iDestApRecordStatus = ECmmRecordStatusLoaded;

            }

            break;

        case ECmmDestMetadataRecord:

            {

            delete iMetadataRecord;

            iMetadataRecord = static_cast<CCDSNAPMetadataRecord*>( aRecordPointer );

            iMetadataRecordStatus = ECmmRecordStatusLoaded;

            }

            break;

        default:

            {

            ret = KErrNotFound;

            }

            break;

        }

    OstTraceFunctionExit0( CCMMDESTINATIONINSTANCE_SETRECORDPOINTER_EXIT );

    return ret;

    }

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

// Gets a reference to the requested record pointer.

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

//

TInt CCmmDestinationInstance::GetRecordPointer(

        const TCmmDbRecords& aDestRecord,

        CommsDat::CCDRecordBase*& aRecordPointer )

    {

    OstTraceFunctionEntry0( CCMMDESTINATIONINSTANCE_GETRECORDPOINTER_ENTRY );

    TInt ret( KErrNone );

    aRecordPointer = NULL;

    switch ( aDestRecord )

        {

        case ECmmDestNetworkRecord:

            {

            aRecordPointer = static_cast<CommsDat::CCDRecordBase*>( iNetworkRecord );

            }

            break;

        case ECmmDestApRecord:

            {

            aRecordPointer = static_cast<CommsDat::CCDRecordBase*>( iDestApRecord );

            }

            break;

        case ECmmDestMetadataRecord:

            {

            aRecordPointer = static_cast<CommsDat::CCDRecordBase*>( iMetadataRecord );

            }

            break;

        default:

            {

            ASSERT( 0 );

            ret = KErrNotFound;

            }

            break;

        }

    OstTraceFunctionExit0( CCMMDESTINATIONINSTANCE_GETRECORDPOINTER_EXIT );

    return ret;

    }

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

// Save the contents of this destination into database. All connection methods

// including embedded destination, that the client has open handles to, are

// also updated.

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

//

void CCmmDestinationInstance::UpdateL()

    {

    OstTraceFunctionEntry0( CCMMDESTINATIONINSTANCE_UPDATEL_ENTRY );

    if ( AllMandatoryRecordsContainData() )

        {

        // Check for metadata conflicts.

        if ( ConflictingMetadataFoundL() )

            {

            OstTraceFunctionExit0( CCMMDESTINATIONINSTANCE_UPDATEL_EXIT );

            User::Leave( KErrAlreadyExists );

            }

        // Check that the destination name is still valid and not in use already.

        if ( iCache->DestinationExistsWithNameL( iNetworkRecord->iRecordName.GetL(), iId ) )

            {

            OstTraceFunctionExit0( DUP1_CCMMDESTINATIONINSTANCE_UPDATEL_EXIT );

            User::Leave( KErrAlreadyExists );

            }

        iCache->UpdateDestinationL( *this );

        }

    else

        {

        User::Leave( KErrCorrupt );

        }

    OstTraceFunctionExit0( DUP2_CCMMDESTINATIONINSTANCE_UPDATEL_EXIT );

    }

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

// Get the destination name.

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

//

TDesC& CCmmDestinationInstance::GetDestinationNameL()

    {

    OstTraceFunctionEntry0( CCMMDESTINATIONINSTANCE_GETDESTINATIONNAMEL_ENTRY );

    RefreshRecordL( ECmmDestNetworkRecord );

    if ( !iNetworkRecord )

        {

        OstTraceFunctionExit0( CCMMDESTINATIONINSTANCE_GETDESTINATIONNAMEL_EXIT );

        User::Leave( KErrCorrupt );

        }

    OstTraceFunctionExit0( DUP1_CCMMDESTINATIONINSTANCE_GETDESTINATIONNAMEL_EXIT );

    return iNetworkRecord->iRecordName.GetL();

    }

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

// Get the localised destination name.

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

//

HBufC* CCmmDestinationInstance::GetLocalisedDestinationNameL()

    {

    RefreshRecordL( ECmmDestNetworkRecord );

    if ( !iNetworkRecord )

        {

        User::Leave( KErrCorrupt );

        }

    TUint32 purpose( 0 );

    GetMetadataL( CMManager::ESnapMetadataPurpose, purpose );

    HBufC* resolvedText( NULL );

    TBool isLocalised( EFalse );

    switch ( purpose )

        {

        case CMManager::ESnapPurposeInternet:

            {

            _LIT( KDestinationTextId, "txt_occ_dblist_internet");

            resolvedText = CCmManagerTextResolver::ResolveTextL( KDestinationTextId );

            isLocalised = ETrue;

            }

            break;

        case CMManager::ESnapPurposeOperator:

            {

            _LIT( KDestinationTextId, "txt_occ_dblist_operator_services");

            resolvedText = CCmManagerTextResolver::ResolveTextL( KDestinationTextId );

            isLocalised = ETrue;

            }

            break;

        case CMManager::ESnapPurposeIntranet:

            {

            _LIT( KDestinationTextId, "txt_occ_dblist_intranet");

            resolvedText = CCmManagerTextResolver::ResolveTextL( KDestinationTextId );

            isLocalised = ETrue;

            }

            break;

        default:

            break;

        }

    // Not Internet, operator or intranet...or something went wrong 

    if ( !isLocalised || ( isLocalised && !resolvedText ) )

        {

        resolvedText = ( iNetworkRecord->iRecordName.GetL() ).AllocL();

        }

    return resolvedText;

    }

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

// Set the destination name.

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

//

void CCmmDestinationInstance::SetDestinationNameL( const TDesC& aDestinationName )

    {

    OstTraceFunctionEntry0( CCMMDESTINATIONINSTANCE_SETDESTINATIONNAMEL_ENTRY );

    //TODO, capability check depending on destination protection level, or if it is internet destination. Internet destination should be protected always?

    // Write action, load all records.

    LoadAllRecordsL();

    iNetworkRecord->iRecordName.SetL( aDestinationName );

    iDestApRecord->iRecordName.SetL( aDestinationName );

    iNetworkRecordStatus = ECmmRecordStatusModified;

    iDestApRecordStatus = ECmmRecordStatusModified;

    iStatus = ECmmDestinationStatusChanged;

    OstTraceFunctionExit0( CCMMDESTINATIONINSTANCE_SETDESTINATIONNAMEL_EXIT );

    }

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

// Get metadata of specified type.

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

//

void CCmmDestinationInstance::GetMetadataL(

        const CMManager::TSnapMetadataField& aMetadataField,

        TUint32& aMetadata )

    {

    OstTraceFunctionEntry0( CCMMDESTINATIONINSTANCE_GETMETADATAL_ENTRY );

    RefreshRecordL( ECmmDestMetadataRecord );

    if ( !iMetadataRecord )

        {

        OstTraceFunctionExit0( CCMMDESTINATIONINSTANCE_GETMETADATAL_EXIT );

        User::Leave( KErrCorrupt );

        }

    switch ( aMetadataField )

        {

        case CMManager::ESnapMetadataInternet:

            aMetadata = ( TUint32 )( iMetadataRecord->iMetadata ) & CMManager::ESnapMetadataInternet;

            break;

        case CMManager::ESnapMetadataHighlight:

            aMetadata = ( TUint32 )( iMetadataRecord->iMetadata ) & CMManager::ESnapMetadataHighlight;

            break;

        case CMManager::ESnapMetadataHiddenAgent:

            aMetadata = ( TUint32 )( iMetadataRecord->iMetadata ) & CMManager::ESnapMetadataHiddenAgent;

            break;

        case CMManager::ESnapMetadataDestinationIsLocalised: