/*

* 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 RCmConnectionMethod.

*

*/

#include <cmconnectionmethod.h>

#include <cmdestination.h>

#include "cmmserverdefs.h"

#include "cmmanagerapi.h"

#include "cmdestinationwrapper.h"

#include "cmconnectionmethodwrapper.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "cmconnectionmethodTraces.h"

#endif

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

//  RCmConnectionMethod::RCmConnectionMethod()

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

//

EXPORT_C RCmConnectionMethod::RCmConnectionMethod(

        const RCmConnectionMethod& aConnMethod )

    {

    OstTraceFunctionEntry0( RCMCONNECTIONMETHOD_RCMCONNECTIONMETHOD_ENTRY );

    this->iCmConnectionMethodWrapper = aConnMethod.iCmConnectionMethodWrapper;

    if ( iCmConnectionMethodWrapper )

        {

        iCmConnectionMethodWrapper->IncreaseReferenceCounter();

        }

    OstTraceFunctionExit0( RCMCONNECTIONMETHOD_RCMCONNECTIONMETHOD_EXIT );

    }

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

//  RCmConnectionMethod::Close()

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

//

EXPORT_C void RCmConnectionMethod::Close()

    {

    OstTraceFunctionEntry0( RCMCONNECTIONMETHOD_CLOSE_ENTRY );

    if ( iCmConnectionMethodWrapper )

        {

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

            {

            delete iCmConnectionMethodWrapper;

            }

        iCmConnectionMethodWrapper = NULL;

        }

    OstTraceFunctionExit0( RCMCONNECTIONMETHOD_CLOSE_EXIT );

    }

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

//  RCmConnectionMethod::~RCmConnectionMethod()

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

//

EXPORT_C RCmConnectionMethod::~RCmConnectionMethod()

    {

    OstTraceFunctionEntry0( DUP1_RCMCONNECTIONMETHOD_RCMCONNECTIONMETHOD_ENTRY );

    Close();

    OstTraceFunctionExit0( DUP1_RCMCONNECTIONMETHOD_RCMCONNECTIONMETHOD_EXIT );

    }

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

//  RCmConnectionMethod::CreateCopyL()

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

//

EXPORT_C RCmConnectionMethod RCmConnectionMethod::CreateCopyL()

    {

    OstTraceFunctionEntry0( RCMCONNECTIONMETHOD_CREATECOPYL_ENTRY );

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

        {

        User::Leave( KErrBadHandle );

        }

    TInt connMethodHandle = iCmConnectionMethodWrapper->GetHandle();

    CCmConnectionMethodWrapper* cmWrapper = CCmConnectionMethodWrapper::NewLC();

    TInt err = cmWrapper->CreateConnMethodCopy(

            iCmConnectionMethodWrapper->GetMainSession(),

            connMethodHandle );

    User::LeaveIfError( err );

    CleanupStack::Pop( cmWrapper );

    RCmConnectionMethod cm;

    cm.iCmConnectionMethodWrapper = cmWrapper;

    OstTraceFunctionExit0( RCMCONNECTIONMETHOD_CREATECOPYL_EXIT );

    return cm;

    }

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

//  RCmConnectionMethod::GetIntAttributeL()

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

//

EXPORT_C TUint32 RCmConnectionMethod::GetIntAttributeL(

        TUint32 aAttribute ) const

    {

    OstTraceFunctionEntry0( RCMCONNECTIONMETHOD_GETINTATTRIBUTEL_ENTRY );

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

        {

        User::Leave( KErrBadHandle );

        }

    TUint32 value( 0 );

    TInt err = iCmConnectionMethodWrapper->GetIntAttribute( aAttribute, value );

    User::LeaveIfError( err );

    OstTraceFunctionExit0( RCMCONNECTIONMETHOD_GETINTATTRIBUTEL_EXIT );

    return value;

    }

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

//  RCmConnectionMethod::GetBoolAttributeL()

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

//

EXPORT_C TBool RCmConnectionMethod::GetBoolAttributeL(

        TUint32 aAttribute ) const

    {

    OstTraceFunctionEntry0( RCMCONNECTIONMETHOD_GETBOOLATTRIBUTEL_ENTRY );

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

        {

        User::Leave( KErrBadHandle );

        }

    TBool value( 0 );

    TInt err = iCmConnectionMethodWrapper->GetBoolAttribute( aAttribute, value );

    User::LeaveIfError( err );

    OstTraceFunctionExit0( RCMCONNECTIONMETHOD_GETBOOLATTRIBUTEL_EXIT );

    return value;

    }

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

//  RCmConnectionMethod::GetStringAttributeL()

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

//

EXPORT_C HBufC* RCmConnectionMethod::GetStringAttributeL(

        TUint32 aAttribute ) const

    {

    OstTraceFunctionEntry0( RCMCONNECTIONMETHOD_GETSTRINGATTRIBUTEL_ENTRY );

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

        {

        User::Leave( KErrBadHandle );

        }

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

    TInt err = iCmConnectionMethodWrapper->GetStringAttribute( aAttribute, buffer );

    User::LeaveIfError( err );

    if ( buffer->Length() > 0 )

        {

        CleanupStack::Pop( buffer );

        }

    else

        {

        CleanupStack::PopAndDestroy( buffer );

        buffer = NULL;

        buffer = KNullDesC().AllocL();

        }

    OstTraceFunctionExit0( RCMCONNECTIONMETHOD_GETSTRINGATTRIBUTEL_EXIT );

    return buffer;

    }

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

//  RCmConnectionMethod::GetString8AttributeL()

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

//

EXPORT_C HBufC8* RCmConnectionMethod::GetString8AttributeL(

        TUint32 aAttribute ) const

    {

    OstTraceFunctionEntry0( RCMCONNECTIONMETHOD_GETSTRING8ATTRIBUTEL_ENTRY );

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

        {

        User::Leave( KErrBadHandle );

        }

    HBufC8* buffer8 = HBufC8::NewLC( KCmmStringLengthMax );

    TInt err = iCmConnectionMethodWrapper->GetString8Attribute( aAttribute, buffer8 );

    User::LeaveIfError( err );

    if ( buffer8->Length() > 0 )

        {

        CleanupStack::Pop( buffer8 );

        }

    else

        {

        CleanupStack::PopAndDestroy( buffer8 );

        buffer8 = NULL;

        buffer8 = KNullDesC8().AllocL();

        }

    OstTraceFunctionExit0( RCMCONNECTIONMETHOD_GETSTRING8ATTRIBUTEL_EXIT );

    return buffer8;

    }

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

//  RCmConnectionMethod::SetIntAttributeL()

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

//

EXPORT_C void RCmConnectionMethod::SetIntAttributeL(

        TUint32 aAttribute,

        TUint32 aValue )

    {

    OstTraceFunctionEntry0( RCMCONNECTIONMETHOD_SETINTATTRIBUTEL_ENTRY );

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

        {

        User::Leave( KErrBadHandle );

        }

    TInt err = iCmConnectionMethodWrapper->SetIntAttribute( aAttribute, aValue );

    User::LeaveIfError( err );

    OstTraceFunctionExit0( RCMCONNECTIONMETHOD_SETINTATTRIBUTEL_EXIT );

    }

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

//  RCmConnectionMethod::SetBoolAttributeL()

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

//

EXPORT_C void RCmConnectionMethod::SetBoolAttributeL(

        TUint32 aAttribute,

        TBool aValue )

    {

    OstTraceFunctionEntry0( RCMCONNECTIONMETHOD_SETBOOLATTRIBUTEL_ENTRY );

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

        {

        User::Leave( KErrBadHandle );

        }

    TInt err = iCmConnectionMethodWrapper->SetBoolAttribute( aAttribute, aValue );

    User::LeaveIfError( err );

    OstTraceFunctionExit0( RCMCONNECTIONMETHOD_SETBOOLATTRIBUTEL_EXIT );

    }

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

//  RCmConnectionMethod::SetStringAttributeL()

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

//

EXPORT_C void RCmConnectionMethod::SetStringAttributeL(

        TUint32 aAttribute,

        const TDesC16& aValue )

    {

    OstTraceFunctionEntry0( RCMCONNECTIONMETHOD_SETSTRINGATTRIBUTEL_ENTRY );

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

        {

        User::Leave( KErrBadHandle );

        }

    TInt err = iCmConnectionMethodWrapper->SetStringAttribute( aAttribute, aValue );

    User::LeaveIfError( err );

    OstTraceFunctionExit0( RCMCONNECTIONMETHOD_SETSTRINGATTRIBUTEL_EXIT );

    }

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

//  RCmConnectionMethod::SetString8AttributeL()

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

//

EXPORT_C void RCmConnectionMethod::SetString8AttributeL(

        TUint32 aAttribute,

        const TDesC8& aValue )

    {

    OstTraceFunctionEntry0( RCMCONNECTIONMETHOD_SETSTRING8ATTRIBUTEL_ENTRY );

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

        {

        User::Leave( KErrBadHandle );

        }

    TInt err = iCmConnectionMethodWrapper->SetString8Attribute( aAttribute, aValue );

    User::LeaveIfError( err );

    OstTraceFunctionExit0( RCMCONNECTIONMETHOD_SETSTRING8ATTRIBUTEL_EXIT );

    }

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

//  RCmConnectionMethod::UpdateL()

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

//

EXPORT_C void RCmConnectionMethod::UpdateL()

    {

    OstTraceFunctionEntry0( RCMCONNECTIONMETHOD_UPDATEL_ENTRY );

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

        {

        User::Leave( KErrBadHandle );

        }

    TInt err = iCmConnectionMethodWrapper->Update();

    User::LeaveIfError( err );

    OstTraceFunctionExit0( RCMCONNECTIONMETHOD_UPDATEL_EXIT );

    }

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

//  RCmConnectionMethod::DeleteL()

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

//

EXPORT_C TBool RCmConnectionMethod::DeleteL()

    {

    OstTraceFunctionEntry0( RCMCONNECTIONMETHOD_DELETEL_ENTRY );

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

        {

        User::Leave( KErrBadHandle );

        }

    TBool result( ETrue );

    TInt err = iCmConnectionMethodWrapper->Delete( result );

    User::LeaveIfError( err );

    // Instead of calling Close(), we need to force this handle closed even if

    // copies have been made. So we delete the destination wrapper directly.

    delete iCmConnectionMethodWrapper;

    iCmConnectionMethodWrapper = NULL;

    OstTraceFunctionExit0( RCMCONNECTIONMETHOD_DELETEL_EXIT );

    return result;

    }

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

//  RCmConnectionMethod::DestinationL()

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

//

EXPORT_C RCmDestination RCmConnectionMethod::DestinationL() const

    {

    OstTraceFunctionEntry0( RCMCONNECTIONMETHOD_DESTINATIONL_ENTRY );

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

        {

        User::Leave( KErrBadHandle );

        }

    // If client already has a handle open to this destination, give a

    // reference to it.

    CCmDestinationWrapper* destWrap = CCmDestinationWrapper::NewLC();

    TInt connMethodHandle = iCmConnectionMethodWrapper->GetHandle();

    TInt existingHandle( 0 );

    destWrap->GetConnMethodAsEmbeddedDestL(

            iCmConnectionMethodWrapper->GetMainSession(),

            connMethodHandle,

            existingHandle );

    if ( existingHandle )

        {

        CleanupStack::PopAndDestroy( destWrap );

        destWrap = iCmConnectionMethodWrapper->GetMainSession()->GetDestinationWrapperL(

                existingHandle );

        destWrap->IncreaseReferenceCounter();

        }

    else

        {

        CleanupStack::Pop( destWrap );

        }

    RCmDestination dest;

    dest.iCmDestinationWrapper = destWrap;

    OstTraceFunctionExit0( RCMCONNECTIONMETHOD_DESTINATIONL_EXIT );

    return dest;

    }

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

//  RCmConnectionMethod::RCmConnectionMethod()

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

//

EXPORT_C RCmConnectionMethod::RCmConnectionMethod() : iCmConnectionMethodWrapper( NULL )

    {

    OstTraceFunctionEntry0( DUP2_RCMCONNECTIONMETHOD_RCMCONNECTIONMETHOD_ENTRY );

    OstTraceFunctionExit0( DUP2_RCMCONNECTIONMETHOD_RCMCONNECTIONMETHOD_EXIT );

    }

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

//  RCmConnectionMethod::operator=()

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

//

EXPORT_C RCmConnectionMethod& RCmConnectionMethod::operator=(

        const RCmConnectionMethod& aConnMethod )

    {

    OstTraceFunctionEntry0( RCMCONNECTIONMETHOD_OPERATOR_ENTRY );

    if ( this != &aConnMethod )

        {

        Close();

        this->iCmConnectionMethodWrapper = aConnMethod.iCmConnectionMethodWrapper;

        if ( iCmConnectionMethodWrapper )

            {

            iCmConnectionMethodWrapper->IncreaseReferenceCounter();

            }

        }

    OstTraceFunctionExit0( RCMCONNECTIONMETHOD_OPERATOR_EXIT );

    return *this;

    }

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

//  RCmConnectionMethod::operator==()

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

//

EXPORT_C TBool RCmConnectionMethod::operator==( RCmConnectionMethod& aConnMethod ) const

    {

    OstTraceFunctionEntry0( DUP1_RCMCONNECTIONMETHOD_OPERATOR_ENTRY );

    TBool result( EFalse );

    if ( !aConnMethod.iCmConnectionMethodWrapper )

        {

        if ( !iCmConnectionMethodWrapper )

            {

            result = ETrue; // Both empty.

            }

        else

            {

            result = EFalse;

            }

        }

    else if ( !iCmConnectionMethodWrapper )

        {

        result = EFalse;

        }

    else

        {

        // Both connection method objects have wrappers.

        if ( !iCmConnectionMethodWrapper->SessionConnected() ||

                !aConnMethod.iCmConnectionMethodWrapper->SessionConnected() )

            {

            result = EFalse;

            }

        else

            {

            // Both connection method objects are connected to server.

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

            TInt err = iCmConnectionMethodWrapper->IsEqual( handle, result );

            if ( err )

                {

                result = EFalse;

                }

            }

        }

    OstTraceFunctionExit0( DUP1_RCMCONNECTIONMETHOD_OPERATOR_EXIT );

    return result;

    }

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

//

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

//

EXPORT_C TBool RCmConnectionMethod::operator!=( RCmConnectionMethod& aConnMethod ) const

    {

    OstTraceFunctionEntry0( DUP2_RCMCONNECTIONMETHOD_OPERATOR_ENTRY );

    TBool result = !( operator==( aConnMethod ) );

    OstTraceFunctionExit0( DUP2_RCMCONNECTIONMETHOD_OPERATOR_EXIT );

    return result;

    }

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

//  RCmConnectionMethod::GetIconL()

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

//

EXPORT_C HBufC* RCmConnectionMethod::GetIconL() const

    {

    OstTraceFunctionEntry0( RCMCONNECTIONMETHOD_GETICONL_ENTRY );

    User::Leave( KErrNotSupported );

    OstTraceFunctionExit0( RCMCONNECTIONMETHOD_GETICONL_EXIT );

    return NULL;

    }

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

//  RCmConnectionMethod::SetIconL()

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

//

EXPORT_C void RCmConnectionMethod::SetIconL( const TDesC& /*aIcon*/ )

    {

    OstTraceFunctionEntry0( RCMCONNECTIONMETHOD_SETICONL_ENTRY );

    User::Leave( KErrNotSupported );

    OstTraceFunctionExit0( RCMCONNECTIONMETHOD_SETICONL_EXIT );

    }

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

//  RCmConnectionMethod::RefreshL()

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

//

EXPORT_C void RCmConnectionMethod::RefreshL()

    {

    OstTraceFunctionEntry0( RCMCONNECTIONMETHOD_REFRESHL_ENTRY );

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

        {

        User::Leave( KErrBadHandle );

        }