/*

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

*

*/

#include <cmmanagerext.h>

#include <cmconnectionmethodext.h>

#include <cmdestinationext.h>

#include "cmmserverdefs.h"

#include "cmmanagerapi.h"

#include "cmconnectionmethodwrapper.h"

#include "cmdestinationwrapper.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "cmmanagerextTraces.h"

#endif

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

//  RCmManagerExt::OpenL()

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

//

EXPORT_C void RCmManagerExt::OpenL()

    {

    OstTraceFunctionEntry0( RCMMANAGEREXT_OPENL_ENTRY );

    OpenLC();

    CleanupStack::Pop( this );

    OstTraceFunctionExit0( RCMMANAGEREXT_OPENL_EXIT );

    }

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

//  RCmManagerExt::OpenLC()

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

//

EXPORT_C void RCmManagerExt::OpenLC()

    {

    OstTraceFunctionEntry0( RCMMANAGEREXT_OPENLC_ENTRY );

    if ( iCmManagerApi )

        {

        User::Leave( KErrAlreadyExists );

        }

    CleanupClosePushL( *this );

    iCmManagerApi = new (ELeave) RCmManagerApi();

    User::LeaveIfError( iCmManagerApi->Connect() );

    OstTraceFunctionExit0( RCMMANAGEREXT_OPENLC_EXIT );

    }

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

//  RCmManagerExt::Close()

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

//

EXPORT_C void RCmManagerExt::Close()

    {

    OstTraceFunctionEntry0( RCMMANAGEREXT_CLOSE_ENTRY );

    if ( iCmManagerApi )

        {

        iCmManagerApi->Close();

        delete iCmManagerApi;

        iCmManagerApi = NULL;

        }

    OstTraceFunctionExit0( RCMMANAGEREXT_CLOSE_EXIT );

    }

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

//  RCmManagerExt::CreateTablesAndOpenL()

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

//

EXPORT_C void RCmManagerExt::CreateTablesAndOpenL()

    {

    OstTraceFunctionEntry0( RCMMANAGEREXT_CREATETABLESANDOPENL_ENTRY );

    OpenL();

    OstTraceFunctionExit0( RCMMANAGEREXT_CREATETABLESANDOPENL_EXIT );

    }

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

//  RCmManagerExt::ConnectionMethodL()

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

//

EXPORT_C RCmConnectionMethodExt RCmManagerExt::ConnectionMethodL(

        TUint32 aConnectionMethodId )

    {

    OstTraceFunctionEntry0( RCMMANAGEREXT_CONNECTIONMETHODL_ENTRY );

    if ( !iCmManagerApi )

        {

        User::Leave( KErrBadHandle );

        }

    if ( !( ( aConnectionMethodId > KCmmConnMethodIdIntervalMin ) &&

            ( aConnectionMethodId < KCmmConnMethodIdIntervalMax ) ) )

        {

        User::Leave( KErrArgument );

        }

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

    // reference to it.

    CCmConnectionMethodWrapper* cmWrapper = CCmConnectionMethodWrapper::NewLC();

    TInt existingHandle( 0 );

    cmWrapper->GetConnMethodWithIdL( iCmManagerApi, aConnectionMethodId, existingHandle );

    if ( existingHandle )

        {

        CleanupStack::PopAndDestroy( cmWrapper );

        cmWrapper = iCmManagerApi->GetConnMethodWrapperL( existingHandle );

        cmWrapper->IncreaseReferenceCounter();

        }

    else

        {

        CleanupStack::Pop( cmWrapper );

        }

    RCmConnectionMethodExt cm;

    cm.iCmConnectionMethodWrapper = cmWrapper;

    OstTraceFunctionExit0( RCMMANAGEREXT_CONNECTIONMETHODL_EXIT );

    return cm;

    }

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

//  RCmManagerExt::GetBearerInfoIntL()

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

//

EXPORT_C TUint32 RCmManagerExt::GetBearerInfoIntL(

        TUint32 aBearerType,

        TUint32 aAttribute ) const

    {

    OstTraceFunctionEntry0( RCMMANAGEREXT_GETBEARERINFOINTL_ENTRY );

    if ( !iCmManagerApi )

        {

        User::Leave( KErrBadHandle );

        }

    TUint32 value( 0 );

    TInt err = iCmManagerApi->GetBearerInfoInt( aBearerType, aAttribute, value );

    User::LeaveIfError( err );

    OstTraceFunctionExit0( RCMMANAGEREXT_GETBEARERINFOINTL_EXIT );

    return value;

    }

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

//  RCmManagerExt::GetBearerInfoBoolL()

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

//

EXPORT_C TBool RCmManagerExt::GetBearerInfoBoolL(

        TUint32 aBearerType,

        TUint32 aAttribute ) const

    {

    OstTraceFunctionEntry0( RCMMANAGEREXT_GETBEARERINFOBOOLL_ENTRY );

    if ( !iCmManagerApi )

        {

        User::Leave( KErrBadHandle );

        }

    TBool value( 0 );

    TInt err = iCmManagerApi->GetBearerInfoBool( aBearerType, aAttribute, value );

    User::LeaveIfError( err );

    OstTraceFunctionExit0( RCMMANAGEREXT_GETBEARERINFOBOOLL_EXIT );

    return value;

    }

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

//  RCmManagerExt::GetBearerInfoStringL()

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

//

EXPORT_C HBufC* RCmManagerExt::GetBearerInfoStringL(

        TUint32 aBearerType,

        TUint32 aAttribute ) const

    {

    OstTraceFunctionEntry0( RCMMANAGEREXT_GETBEARERINFOSTRINGL_ENTRY );

    if ( !iCmManagerApi )

        {

        User::Leave( KErrBadHandle );

        }

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

    TInt err = iCmManagerApi->GetBearerInfoString( aBearerType, aAttribute, buffer );

    User::LeaveIfError( err );

    if ( buffer->Length() > 0 )

        {

        CleanupStack::Pop( buffer );

        }

    else

        {

        CleanupStack::PopAndDestroy( buffer );

        buffer = NULL;

        buffer = KNullDesC().AllocL();

        }

    OstTraceFunctionExit0( RCMMANAGEREXT_GETBEARERINFOSTRINGL_EXIT );

    return buffer;

    }

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

//  RCmManagerExt::GetBearerInfoString8L()

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

//

EXPORT_C HBufC8* RCmManagerExt::GetBearerInfoString8L(

        TUint32 aBearerType,

        TUint32 aAttribute ) const

    {

    OstTraceFunctionEntry0( RCMMANAGEREXT_GETBEARERINFOSTRING8L_ENTRY );

    if ( !iCmManagerApi )

        {

        User::Leave( KErrBadHandle );

        }

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

    TInt err = iCmManagerApi->GetBearerInfoString8( aBearerType, aAttribute, buffer8 );

    User::LeaveIfError( err );

    if ( buffer8->Length() > 0 )

        {

        CleanupStack::Pop( buffer8 );

        }

    else

        {

        CleanupStack::PopAndDestroy( buffer8 );

        buffer8 = NULL;

        buffer8 = KNullDesC8().AllocL();

        }

    OstTraceFunctionExit0( RCMMANAGEREXT_GETBEARERINFOSTRING8L_EXIT );

    return buffer8;

    }

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

//  RCmManagerExt::GetConnectionMethodInfoIntL()

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

//

EXPORT_C TUint32 RCmManagerExt::GetConnectionMethodInfoIntL(

        TUint32 aIapId,

        TUint32 aAttribute ) const

    {

    OstTraceFunctionEntry0( RCMMANAGEREXT_GETCONNECTIONMETHODINFOINTL_ENTRY );

    if ( !iCmManagerApi )

        {

        User::Leave( KErrBadHandle );

        }

    TUint32 value( 0 );

    TInt err = iCmManagerApi->GetConnectionMethodInfoInt( aIapId, aAttribute, value );

    User::LeaveIfError( err );

    OstTraceFunctionExit0( RCMMANAGEREXT_GETCONNECTIONMETHODINFOINTL_EXIT );

    return value;

    }

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

//  RCmManagerExt::GetConnectionMethodInfoBoolL()

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

//

EXPORT_C TBool RCmManagerExt::GetConnectionMethodInfoBoolL(

        TUint32 aIapId,

        TUint32 aAttribute ) const

    {

    OstTraceFunctionEntry0( RCMMANAGEREXT_GETCONNECTIONMETHODINFOBOOLL_ENTRY );

    if ( !iCmManagerApi )

        {

        User::Leave( KErrBadHandle );

        }

    TBool value( 0 );

    TInt err = iCmManagerApi->GetConnectionMethodInfoBool( aIapId, aAttribute, value );

    User::LeaveIfError( err );

    OstTraceFunctionExit0( RCMMANAGEREXT_GETCONNECTIONMETHODINFOBOOLL_EXIT );

    return value;

    }

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

//  RCmManagerExt::GetConnectionMethodInfoStringL()

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

//

EXPORT_C HBufC* RCmManagerExt::GetConnectionMethodInfoStringL(

        TUint32 aIapId,

        TUint32 aAttribute ) const

    {

    OstTraceFunctionEntry0( RCMMANAGEREXT_GETCONNECTIONMETHODINFOSTRINGL_ENTRY );

    if ( !iCmManagerApi )

        {

        User::Leave( KErrBadHandle );

        }

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

    TInt err = iCmManagerApi->GetConnectionMethodInfoString( aIapId, aAttribute, buffer );

    User::LeaveIfError( err );

    if ( buffer->Length() > 0 )

        {

        CleanupStack::Pop( buffer );

        }

    else

        {

        CleanupStack::PopAndDestroy( buffer );

        buffer = NULL;

        buffer = KNullDesC().AllocL();

        }

    OstTraceFunctionExit0( RCMMANAGEREXT_GETCONNECTIONMETHODINFOSTRINGL_EXIT );

    return buffer;

    }

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

//  RCmManagerExt::GetConnectionMethodInfoString8L()

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

//

EXPORT_C HBufC8* RCmManagerExt::GetConnectionMethodInfoString8L(

        TUint32 aIapId,

        TUint32 aAttribute ) const

    {

    OstTraceFunctionEntry0( RCMMANAGEREXT_GETCONNECTIONMETHODINFOSTRING8L_ENTRY );

    if ( !iCmManagerApi )

        {

        User::Leave( KErrBadHandle );

        }

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

    TInt err = iCmManagerApi->GetConnectionMethodInfoString8( aIapId, aAttribute, buffer8 );

    User::LeaveIfError( err );

    if ( buffer8->Length() > 0 )

        {

        CleanupStack::Pop( buffer8 );

        }

    else

        {

        CleanupStack::PopAndDestroy( buffer8 );

        buffer8 = NULL;

        buffer8 = KNullDesC8().AllocL();

        }

    OstTraceFunctionExit0( RCMMANAGEREXT_GETCONNECTIONMETHODINFOSTRING8L_EXIT );

    return buffer8;

    }

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

//  RCmManagerExt::CreateDestinationL()

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

//

EXPORT_C RCmDestinationExt RCmManagerExt::CreateDestinationL(

        const TDesC& aName )

    {

    OstTraceFunctionEntry0( RCMMANAGEREXT_CREATEDESTINATIONL_ENTRY );

    if ( !iCmManagerApi )

        {

        User::Leave( KErrBadHandle );

        }

    if ( aName.Length() == 0 )

        {

        User::Leave( KErrArgument );

        }

    CCmDestinationWrapper* destWrap = CCmDestinationWrapper::NewLC();

    destWrap->CreateDestByNameL( iCmManagerApi, aName );

    CleanupStack::Pop( destWrap );

    RCmDestinationExt dest;

    dest.iCmDestinationWrapper = destWrap;

    OstTraceFunctionExit0( RCMMANAGEREXT_CREATEDESTINATIONL_EXIT );

    return dest;

    }

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

//  RCmManagerExt::CreateConnectionMethodL()

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

//

EXPORT_C RCmConnectionMethodExt RCmManagerExt::CreateConnectionMethodL(

        TUint32 aBearerType )

    {

    OstTraceFunctionEntry0( RCMMANAGEREXT_CREATECONNECTIONMETHODL_ENTRY );

    if ( !iCmManagerApi )

        {

        User::Leave( KErrBadHandle );

        }

    CCmConnectionMethodWrapper* cmWrapper = CCmConnectionMethodWrapper::NewLC();

    cmWrapper->CreateConnMethodL( iCmManagerApi, aBearerType );

    CleanupStack::Pop( cmWrapper );

    RCmConnectionMethodExt cm;

    cm.iCmConnectionMethodWrapper = cmWrapper;

    OstTraceFunctionExit0( RCMMANAGEREXT_CREATECONNECTIONMETHODL_EXIT );

    return cm;

    }

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

//  RCmManagerExt::CopyConnectionMethodL()

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

//

EXPORT_C TInt RCmManagerExt::CopyConnectionMethodL(

        RCmDestinationExt& aTargetDestination,

        RCmConnectionMethodExt& aConnectionMethod )

    {

    OstTraceFunctionEntry0( RCMMANAGEREXT_COPYCONNECTIONMETHODL_ENTRY );

    if ( !iCmManagerApi )

        {

        User::Leave( KErrBadHandle );

        }

    if ( !aTargetDestination.iCmDestinationWrapper ||

            !aConnectionMethod.iCmConnectionMethodWrapper )

        {

        User::Leave( KErrArgument );

        }

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

            !aConnectionMethod.iCmConnectionMethodWrapper->SessionConnected() )

        {

        User::Leave( KErrArgument );

        }

    TInt index( 0 );

    TInt targetDestHandle = aTargetDestination.iCmDestinationWrapper->GetHandle();

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

    TInt err = iCmManagerApi->CopyConnectionMethod( targetDestHandle, connMethodHandle, index );

    User::LeaveIfError( err );

    OstTraceFunctionExit0( RCMMANAGEREXT_COPYCONNECTIONMETHODL_EXIT );

    return index;

    }

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

//  RCmManagerExt::MoveConnectionMethodL()

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

//

EXPORT_C TInt RCmManagerExt::MoveConnectionMethodL(

        RCmDestinationExt& aSourceDestination,

        RCmDestinationExt& aTargetDestination,

        RCmConnectionMethodExt& aConnectionMethod )

    {

    OstTraceFunctionEntry0( RCMMANAGEREXT_MOVECONNECTIONMETHODL_ENTRY );

    if ( !iCmManagerApi )

        {

        User::Leave( KErrBadHandle );

        }

    if ( !aSourceDestination.iCmDestinationWrapper ||

            !aTargetDestination.iCmDestinationWrapper ||

            !aConnectionMethod.iCmConnectionMethodWrapper )

        {

        User::Leave( KErrArgument );

        }

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

            !aTargetDestination.iCmDestinationWrapper->SessionConnected() ||

            !aConnectionMethod.iCmConnectionMethodWrapper->SessionConnected() )

        {

        User::Leave( KErrArgument );

        }

    TCmmIpcStructMoveConnMethod pkgData;

    pkgData.iSourceDestHandle = aSourceDestination.iCmDestinationWrapper->GetHandle();

    pkgData.iTargetDestHandle = aTargetDestination.iCmDestinationWrapper->GetHandle();

    pkgData.iConnMethodHandle = aConnectionMethod.iCmConnectionMethodWrapper->GetHandle();

    pkgData.iIndex = 0;

    TInt err = iCmManagerApi->MoveConnectionMethod( pkgData );

    User::LeaveIfError( err );

    OstTraceFunctionExit0( RCMMANAGEREXT_MOVECONNECTIONMETHODL_EXIT );

    return pkgData.iIndex;

    }

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

//  RCmManagerExt::RemoveConnectionMethodL()

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

//

EXPORT_C void RCmManagerExt::RemoveConnectionMethodL(

        RCmDestinationExt& aDestination,

        RCmConnectionMethodExt& aConnectionMethod )

    {

    OstTraceFunctionEntry0( RCMMANAGEREXT_REMOVECONNECTIONMETHODL_ENTRY );

    if ( !iCmManagerApi )

        {

        User::Leave( KErrBadHandle );

        }

    if ( !aDestination.iCmDestinationWrapper ||

            !aConnectionMethod.iCmConnectionMethodWrapper )

        {

        User::Leave( KErrArgument );

        }

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

            !aConnectionMethod.iCmConnectionMethodWrapper->SessionConnected() )

        {

        User::Leave( KErrArgument );

        }

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