/*

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

* Implementation of RCmDestination.

*

*/

#include <cmdestination.h>

#include <cmconnectionmethod.h>

#include "cmmserverdefs.h"

#include "cmmanagerapi.h"

#include "cmdestinationwrapper.h"

#include "cmconnectionmethodwrapper.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "cmdestinationTraces.h"

#endif

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

//  RCmDestination::Close()

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

//

EXPORT_C void RCmDestination::Close()

    {

    OstTraceFunctionEntry0( RCMDESTINATION_CLOSE_ENTRY );

    if ( iCmDestinationWrapper )

        {

        if ( iCmDestinationWrapper->DecreaseReferenceCounter() <= 0 )

            {

            delete iCmDestinationWrapper;

            }

        iCmDestinationWrapper = NULL;

        }

    OstTraceFunctionExit0( RCMDESTINATION_CLOSE_EXIT );

    }

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

//  RCmDestination::~RCmDestination()

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

//

EXPORT_C RCmDestination::~RCmDestination()

    {

    OstTraceFunctionEntry0( RCMDESTINATION_RCMDESTINATION_ENTRY );

    Close();

    OstTraceFunctionExit0( RCMDESTINATION_RCMDESTINATION_EXIT );

    }

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

//  RCmDestination::RCmDestination()

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

//

EXPORT_C RCmDestination::RCmDestination(

        const RCmDestination& aDestination )

    {

    OstTraceFunctionEntry0( DUP1_RCMDESTINATION_RCMDESTINATION_ENTRY );

    this->iCmDestinationWrapper = aDestination.iCmDestinationWrapper;

    if ( iCmDestinationWrapper )

        {

        iCmDestinationWrapper->IncreaseReferenceCounter();

        }

    OstTraceFunctionExit0( DUP1_RCMDESTINATION_RCMDESTINATION_EXIT );

    }

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

//  RCmDestination::operator=()

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

//

EXPORT_C RCmDestination& RCmDestination::operator=(

        const RCmDestination& aDestination )

    {

    OstTraceFunctionEntry0( RCMDESTINATION_OPERATOR_ENTRY );

    if ( this != &aDestination )

        {

        Close();

        this->iCmDestinationWrapper = aDestination.iCmDestinationWrapper;

        if ( iCmDestinationWrapper )

            {

            iCmDestinationWrapper->IncreaseReferenceCounter();

            }

        }

    OstTraceFunctionExit0( RCMDESTINATION_OPERATOR_EXIT );

    return *this;

    }

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

//  RCmDestination::ConnectionMethodCount()

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

//

EXPORT_C TInt RCmDestination::ConnectionMethodCount() const

    {

    OstTraceFunctionEntry0( RCMDESTINATION_CONNECTIONMETHODCOUNT_ENTRY );

    __ASSERT_ALWAYS( iCmDestinationWrapper && iCmDestinationWrapper->SessionConnected(),

            User::Panic( KCmmPanicCategoryApi, EDestNotConnectedToServer ) );

    TInt value( 0 );

    TInt err = iCmDestinationWrapper->ConnectionMethodCount( value );

    if ( err )

        {

        value = 0;

        }

    OstTraceFunctionExit0( RCMDESTINATION_CONNECTIONMETHODCOUNT_EXIT );

    return value;

    }

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

//  RCmDestination::ConnectionMethodL()

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

//

EXPORT_C RCmConnectionMethod RCmDestination::ConnectionMethodL(

        TInt aIndex ) const

    {

    OstTraceFunctionEntry0( RCMDESTINATION_CONNECTIONMETHODL_ENTRY );

    if ( !iCmDestinationWrapper || !iCmDestinationWrapper->SessionConnected() )

        {

        User::Leave( KErrBadHandle );

        }

    CCmConnectionMethodWrapper* cmWrapper = CCmConnectionMethodWrapper::NewLC();

    TInt destHandle = iCmDestinationWrapper->GetHandle();

    TInt existingHandle( 0 );

    cmWrapper->GetConnMethodFromDestWithIndexL(

            iCmDestinationWrapper->GetMainSession(),

            destHandle,

            aIndex,

            existingHandle );

    if ( existingHandle )

        {

        CleanupStack::PopAndDestroy( cmWrapper );

        cmWrapper = iCmDestinationWrapper->GetMainSession()->GetConnMethodWrapperL( existingHandle );

        cmWrapper->IncreaseReferenceCounter();

        }

    else

        {

        CleanupStack::Pop( cmWrapper );

        }

    RCmConnectionMethod cm;

    cm.iCmConnectionMethodWrapper = cmWrapper;

    OstTraceFunctionExit0( RCMDESTINATION_CONNECTIONMETHODL_EXIT );

    return cm;

    }

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

//  RCmDestination::ConnectionMethodByIDL()

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

//

EXPORT_C RCmConnectionMethod RCmDestination::ConnectionMethodByIDL(

        TInt aConnMethodId ) const

    {

    OstTraceFunctionEntry0( RCMDESTINATION_CONNECTIONMETHODBYIDL_ENTRY );

    if ( !iCmDestinationWrapper || !iCmDestinationWrapper->SessionConnected() )

        {

        User::Leave( KErrBadHandle );

        }

    CCmConnectionMethodWrapper* cmWrapper = CCmConnectionMethodWrapper::NewLC();

    TInt destHandle = iCmDestinationWrapper->GetHandle();

    TInt existingHandle( 0 );

    cmWrapper->GetConnMethodFromDestWithIdL(

            iCmDestinationWrapper->GetMainSession(),

            destHandle,

            aConnMethodId,

            existingHandle );

    if ( existingHandle )

        {

        CleanupStack::PopAndDestroy( cmWrapper );

        cmWrapper = iCmDestinationWrapper->GetMainSession()->GetConnMethodWrapperL(

                existingHandle );

        cmWrapper->IncreaseReferenceCounter();

        }

    else

        {

        CleanupStack::Pop( cmWrapper );

        }

    RCmConnectionMethod cm;

    cm.iCmConnectionMethodWrapper = cmWrapper;

    OstTraceFunctionExit0( RCMDESTINATION_CONNECTIONMETHODBYIDL_EXIT );

    return cm;

    }

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

//  RCmDestination::PriorityL()

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

//

EXPORT_C TUint RCmDestination::PriorityL(

        const RCmConnectionMethod& aConnectionMethod ) const

    {

    OstTraceFunctionEntry0( RCMDESTINATION_PRIORITYL_ENTRY );

    if ( !iCmDestinationWrapper || !iCmDestinationWrapper->SessionConnected() )

        {

        User::Leave( KErrBadHandle );

        }

    if ( !aConnectionMethod.iCmConnectionMethodWrapper ||

            !aConnectionMethod.iCmConnectionMethodWrapper->SessionConnected() )

        {

        User::Leave( KErrArgument );

        }

    TUint priority( 0 );

    TInt handle = aConnectionMethod.iCmConnectionMethodWrapper->GetHandle();

    TInt err = iCmDestinationWrapper->Priority( handle, priority );

    User::LeaveIfError( err );

    OstTraceFunctionExit0( RCMDESTINATION_PRIORITYL_EXIT );

    return priority;

    }

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

//  RCmDestination::NameLC()

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

//

EXPORT_C HBufC* RCmDestination::NameLC() const

    {

    OstTraceFunctionEntry0( RCMDESTINATION_NAMELC_ENTRY );

    if ( !iCmDestinationWrapper || !iCmDestinationWrapper->SessionConnected() )

        {

        User::Leave( KErrBadHandle );

        }

    HBufC* buffer = HBufC::NewLC( KCmmStringLengthMax );

    TInt err = iCmDestinationWrapper->GetName( buffer );

    User::LeaveIfError( err );

    // Leave buffer in cleanup stack.

    OstTraceFunctionExit0( RCMDESTINATION_NAMELC_EXIT );

    return buffer;

    }

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

//  RCmDestination::Id()

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

//

EXPORT_C TUint32 RCmDestination::Id() const

    {

    OstTraceFunctionEntry0( RCMDESTINATION_ID_ENTRY );

    __ASSERT_ALWAYS( iCmDestinationWrapper && iCmDestinationWrapper->SessionConnected(),

            User::Panic( KCmmPanicCategoryApi, EDestNotConnectedToServer ) );

    TUint32 id( 0 );

    TInt err = iCmDestinationWrapper->GetId( id );

    if ( err )

        {

        id = 0;

        }

    OstTraceFunctionExit0( RCMDESTINATION_ID_EXIT );

    return id;

    }

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

//  RCmDestination::ElementId()

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

//

EXPORT_C TUint32 RCmDestination::ElementId() const

    {

    OstTraceFunctionEntry0( RCMDESTINATION_ELEMENTID_ENTRY );

    __ASSERT_ALWAYS( iCmDestinationWrapper && iCmDestinationWrapper->SessionConnected(),

            User::Panic( KCmmPanicCategoryApi, EDestNotConnectedToServer ) );

    TUint32 elementId( 0 );

    TInt err = iCmDestinationWrapper->GetElementId( elementId );

    if ( err )

        {

        elementId = 0;

        }

    OstTraceFunctionExit0( RCMDESTINATION_ELEMENTID_EXIT );

    return elementId;

    }

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

//  RCmDestination::MetadataL()

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

//

EXPORT_C TUint32 RCmDestination::MetadataL(

        CMManager::TSnapMetadataField aMetadataField ) const

    {

    OstTraceFunctionEntry0( RCMDESTINATION_METADATAL_ENTRY );

    if ( !iCmDestinationWrapper || !iCmDestinationWrapper->SessionConnected() )

        {

        User::Leave( KErrBadHandle );

        }

    TUint32 value( 0 );

    TInt err = iCmDestinationWrapper->GetMetadata( aMetadataField, value );

    User::LeaveIfError( err );

    OstTraceFunctionExit0( RCMDESTINATION_METADATAL_EXIT );

    return value;

    }

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

//  RCmDestination::ProtectionLevel()

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

//

EXPORT_C CMManager::TProtectionLevel RCmDestination::ProtectionLevel() const

    {

    OstTraceFunctionEntry0( RCMDESTINATION_PROTECTIONLEVEL_ENTRY );

    __ASSERT_ALWAYS( iCmDestinationWrapper && iCmDestinationWrapper->SessionConnected(),

            User::Panic( KCmmPanicCategoryApi, EDestNotConnectedToServer ) );

    TInt protectionLevel( CMManager::EProtLevel0 );

    TInt err = iCmDestinationWrapper->GetProtectionLevel( protectionLevel );

    if ( err )

        {

        protectionLevel = CMManager::EProtLevel0;

        }

    OstTraceFunctionExit0( RCMDESTINATION_PROTECTIONLEVEL_EXIT );

    return ( CMManager::TProtectionLevel )protectionLevel;

    }

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

//  RCmDestination::IsHidden()

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

//

EXPORT_C TBool RCmDestination::IsHidden() const

    {

    OstTraceFunctionEntry0( RCMDESTINATION_ISHIDDEN_ENTRY );

    __ASSERT_ALWAYS( iCmDestinationWrapper && iCmDestinationWrapper->SessionConnected(),

            User::Panic( KCmmPanicCategoryApi, EDestNotConnectedToServer ) );

    TBool value( EFalse );

    TInt err = iCmDestinationWrapper->IsHidden( value );

    if ( err )

        {

        value = EFalse;

        }

    OstTraceFunctionExit0( RCMDESTINATION_ISHIDDEN_EXIT );

    return value;

    }

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

//  RCmDestination::CreateConnectionMethodL()

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

//

EXPORT_C RCmConnectionMethod RCmDestination::CreateConnectionMethodL(

        TUint32 aBearerType )

    {

    OstTraceFunctionEntry0( RCMDESTINATION_CREATECONNECTIONMETHODL_ENTRY );

    if ( !iCmDestinationWrapper || !iCmDestinationWrapper->SessionConnected() )

        {

        User::Leave( KErrBadHandle );

        }

    CCmConnectionMethodWrapper* cmWrapper = CCmConnectionMethodWrapper::NewLC();

    TInt destHandle = iCmDestinationWrapper->GetHandle();

    cmWrapper->CreateConnMethodToDestL(

            iCmDestinationWrapper->GetMainSession(),

            destHandle,

            aBearerType );

    CleanupStack::Pop( cmWrapper );

    RCmConnectionMethod cm;

    cm.iCmConnectionMethodWrapper = cmWrapper;

    OstTraceFunctionExit0( RCMDESTINATION_CREATECONNECTIONMETHODL_EXIT );

    return cm;

    }

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

//  RCmDestination::CreateConnectionMethodL()

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

//

EXPORT_C RCmConnectionMethod RCmDestination::CreateConnectionMethodL(

        TUint32 aBearerType,

        TUint32 aConnMethodId )

    {

    OstTraceFunctionEntry0( DUP1_RCMDESTINATION_CREATECONNECTIONMETHODL_ENTRY );

    if ( !iCmDestinationWrapper || !iCmDestinationWrapper->SessionConnected() )

        {

        User::Leave( KErrBadHandle );

        }

    CCmConnectionMethodWrapper* cmWrapper = CCmConnectionMethodWrapper::NewLC();

    TInt destHandle = iCmDestinationWrapper->GetHandle();

    cmWrapper->CreateConnMethodToDestWithIdL(

            iCmDestinationWrapper->GetMainSession(),

            destHandle,

            aBearerType,

            aConnMethodId );

    CleanupStack::Pop( cmWrapper );

    RCmConnectionMethod cm;

    cm.iCmConnectionMethodWrapper = cmWrapper;

    OstTraceFunctionExit0( DUP1_RCMDESTINATION_CREATECONNECTIONMETHODL_EXIT );

    return cm;

    }

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

//  RCmDestination::AddConnectionMethodL()

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

//

EXPORT_C TInt RCmDestination::AddConnectionMethodL(

        RCmConnectionMethod aConnectionMethod )

    {

    OstTraceFunctionEntry0( RCMDESTINATION_ADDCONNECTIONMETHODL_ENTRY );

    if ( !iCmDestinationWrapper || !iCmDestinationWrapper->SessionConnected() )

        {

        User::Leave( KErrBadHandle );

        }

    if ( !aConnectionMethod.iCmConnectionMethodWrapper ||

            !aConnectionMethod.iCmConnectionMethodWrapper->SessionConnected() )

        {

        User::Leave( KErrArgument );

        }

    TInt index( 0 );

    TInt connMethodHandle = aConnectionMethod.iCmConnectionMethodWrapper->GetHandle();

    TInt err = iCmDestinationWrapper->AddConnectionMethod( connMethodHandle, index );

    User::LeaveIfError( err );

    OstTraceFunctionExit0( RCMDESTINATION_ADDCONNECTIONMETHODL_EXIT );

    return index;

    }

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

//  RCmDestination::AddEmbeddedDestinationL()

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

//

EXPORT_C TInt RCmDestination::AddEmbeddedDestinationL(

        const RCmDestination& aDestination )

    {

    OstTraceFunctionEntry0( RCMDESTINATION_ADDEMBEDDEDDESTINATIONL_ENTRY );

    if ( !iCmDestinationWrapper || !iCmDestinationWrapper->SessionConnected() )

        {

        User::Leave( KErrBadHandle );

        }

    if ( iCmDestinationWrapper == aDestination.iCmDestinationWrapper )

        {

        User::Leave( KErrArgument );

        }

    if ( !aDestination.iCmDestinationWrapper ||

            !aDestination.iCmDestinationWrapper->SessionConnected() )

        {

        User::Leave( KErrArgument );

        }

    TInt index( 0 );

    TInt destinationHandle = aDestination.iCmDestinationWrapper->GetHandle();

    TInt err = iCmDestinationWrapper->AddEmbeddedDestination( destinationHandle, index );

    User::LeaveIfError( err );

    OstTraceFunctionExit0( RCMDESTINATION_ADDEMBEDDEDDESTINATIONL_EXIT );

    return index;

    }

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

//  RCmDestination::DeleteConnectionMethodL()

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

//

EXPORT_C void RCmDestination::DeleteConnectionMethodL(

        RCmConnectionMethod& aConnectionMethod )

    {

    OstTraceFunctionEntry0( RCMDESTINATION_DELETECONNECTIONMETHODL_ENTRY );

    if ( !iCmDestinationWrapper || !iCmDestinationWrapper->SessionConnected() )

        {

        User::Leave( KErrBadHandle );

        }

    if ( !aConnectionMethod.iCmConnectionMethodWrapper ||

            !aConnectionMethod.iCmConnectionMethodWrapper->SessionConnected() )

        {

        User::Leave( KErrArgument );

        }

    TInt connMethodHandle = aConnectionMethod.iCmConnectionMethodWrapper->GetHandle();

    TInt err = iCmDestinationWrapper->DeleteConnectionMethod( connMethodHandle );

    User::LeaveIfError( err );

    OstTraceFunctionExit0( RCMDESTINATION_DELETECONNECTIONMETHODL_EXIT );

    }

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

//  RCmDestination::RemoveConnectionMethodL()

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

//

EXPORT_C void RCmDestination::RemoveConnectionMethodL(

        RCmConnectionMethod aConnectionMethod )

    {

    OstTraceFunctionEntry0( RCMDESTINATION_REMOVECONNECTIONMETHODL_ENTRY );