/*

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

*

*/

#include <cmmanager.h>

#include <cmconnectionmethod.h>

#include <cmdestination.h>

#include "cmmserverdefs.h"

#include "cmmanagerapi.h"

#include "cmconnectionmethodwrapper.h"

#include "cmdestinationwrapper.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "cmmanagerTraces.h"

#endif

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

//  RCmManager::OpenL()

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

//

EXPORT_C void RCmManager::OpenL()

    {

    OstTraceFunctionEntry0( RCMMANAGER_OPENL_ENTRY );

    OpenLC();

    CleanupStack::Pop( this );

    OstTraceFunctionExit0( RCMMANAGER_OPENL_EXIT );

    }

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

//  RCmManager::OpenLC()

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

//

EXPORT_C void RCmManager::OpenLC()

    {

    OstTraceFunctionEntry0( RCMMANAGER_OPENLC_ENTRY );

    if ( iCmManagerApi )

        {

        User::Leave( KErrAlreadyExists );

        }

    CleanupClosePushL( *this );

    iCmManagerApi = new (ELeave) RCmManagerApi();

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

    OstTraceFunctionExit0( RCMMANAGER_OPENLC_EXIT );

    }

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

//  RCmManager::Close()

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

//

EXPORT_C void RCmManager::Close()

    {

    OstTraceFunctionEntry0( RCMMANAGER_CLOSE_ENTRY );

    if ( iCmManagerApi )

        {

        iCmManagerApi->Close();

        delete iCmManagerApi;

        iCmManagerApi = NULL;

        }

    OstTraceFunctionExit0( RCMMANAGER_CLOSE_EXIT );

    }

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

//  RCmManager::CreateTablesAndOpenL()

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

//

EXPORT_C void RCmManager::CreateTablesAndOpenL()

    {

    OstTraceFunctionEntry0( RCMMANAGER_CREATETABLESANDOPENL_ENTRY );

    OpenL();

    OstTraceFunctionExit0( RCMMANAGER_CREATETABLESANDOPENL_EXIT );

    }

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

//  RCmManager::ConnectionMethodL()

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

//

EXPORT_C RCmConnectionMethod RCmManager::ConnectionMethodL(

        TUint32 aConnectionMethodId ) const

    {

    OstTraceFunctionEntry0( RCMMANAGER_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 );

        }

    RCmConnectionMethod cm;

    cm.iCmConnectionMethodWrapper = cmWrapper;

    OstTraceFunctionExit0( DUP1_RCMMANAGER_CONNECTIONMETHODL_EXIT );

    return cm;

    }

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

//  RCmManager::GetBearerInfoIntL()

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

//

EXPORT_C TUint32 RCmManager::GetBearerInfoIntL(

        TUint32 aBearerType,

        TUint32 aAttribute ) const

    {

    OstTraceFunctionEntry0( RCMMANAGER_GETBEARERINFOINTL_ENTRY );

    if ( !iCmManagerApi )

        {

        User::Leave( KErrBadHandle );

        }

    TUint32 value( 0 );

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

    User::LeaveIfError( err );

    OstTraceFunctionExit0( RCMMANAGER_GETBEARERINFOINTL_EXIT );

    return value;

    }

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

//  RCmManager::GetBearerInfoBoolL()

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

//

EXPORT_C TBool RCmManager::GetBearerInfoBoolL(

        TUint32 aBearerType,

        TUint32 aAttribute ) const

    {

    OstTraceFunctionEntry0( RCMMANAGER_GETBEARERINFOBOOLL_ENTRY );

    if ( !iCmManagerApi )

        {

        User::Leave( KErrBadHandle );

        }

    TBool value( 0 );

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

    User::LeaveIfError( err );

    OstTraceFunctionExit0( RCMMANAGER_GETBEARERINFOBOOLL_EXIT );

    return value;

    }

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

//  RCmManager::GetBearerInfoStringL()

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

//

EXPORT_C HBufC* RCmManager::GetBearerInfoStringL(

        TUint32 aBearerType,

        TUint32 aAttribute ) const

    {

    OstTraceFunctionEntry0( RCMMANAGER_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( RCMMANAGER_GETBEARERINFOSTRINGL_EXIT );

    return buffer;

    }

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

//  RCmManager::GetBearerInfoString8L()

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

//

EXPORT_C HBufC8* RCmManager::GetBearerInfoString8L(

        TUint32 aBearerType,

        TUint32 aAttribute ) const

    {

    OstTraceFunctionEntry0( RCMMANAGER_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( RCMMANAGER_GETBEARERINFOSTRING8L_EXIT );

    return buffer8;

    }

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

//  RCmManager::GetConnectionMethodInfoIntL()

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

//

EXPORT_C TUint32 RCmManager::GetConnectionMethodInfoIntL(

        TUint32 aIapId,

        TUint32 aAttribute ) const

    {

    OstTraceFunctionEntry0( RCMMANAGER_GETCONNECTIONMETHODINFOINTL_ENTRY );

    if ( !iCmManagerApi )

        {

        User::Leave( KErrBadHandle );

        }

    TUint32 value( 0 );

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

    User::LeaveIfError( err );

    OstTraceFunctionExit0( RCMMANAGER_GETCONNECTIONMETHODINFOINTL_EXIT );

    return value;

    }

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

//  RCmManager::GetConnectionMethodInfoBoolL()

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

//

EXPORT_C TBool RCmManager::GetConnectionMethodInfoBoolL(

        TUint32 aIapId,

        TUint32 aAttribute ) const

    {

    OstTraceFunctionEntry0( RCMMANAGER_GETCONNECTIONMETHODINFOBOOLL_ENTRY );

    if ( !iCmManagerApi )

        {

        User::Leave( KErrBadHandle );

        }

    TBool value( 0 );

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

    User::LeaveIfError( err );

    OstTraceFunctionExit0( RCMMANAGER_GETCONNECTIONMETHODINFOBOOLL_EXIT );

    return value;

    }

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

//  RCmManager::GetConnectionMethodInfoStringL()

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

//

EXPORT_C HBufC* RCmManager::GetConnectionMethodInfoStringL(

        TUint32 aIapId,

        TUint32 aAttribute ) const

    {

    OstTraceFunctionEntry0( RCMMANAGER_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( RCMMANAGER_GETCONNECTIONMETHODINFOSTRINGL_EXIT );

    return buffer;

    }

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

//  RCmManager::GetConnectionMethodInfoString8L()

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

//

EXPORT_C HBufC8* RCmManager::GetConnectionMethodInfoString8L(

        TUint32 aIapId,

        TUint32 aAttribute ) const

    {

    OstTraceFunctionEntry0( RCMMANAGER_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( RCMMANAGER_GETCONNECTIONMETHODINFOSTRING8L_EXIT );

    return buffer8;

    }

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

//  RCmManager::CreateDestinationL()

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

//

EXPORT_C RCmDestination RCmManager::CreateDestinationL(

        const TDesC& aName )

    {

    OstTraceFunctionEntry0( RCMMANAGER_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 );

    RCmDestination dest;

    dest.iCmDestinationWrapper = destWrap;

    OstTraceFunctionExit0( RCMMANAGER_CREATEDESTINATIONL_EXIT );

    return dest;

    }

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

//  RCmManager::CreateConnectionMethodL()

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

//

EXPORT_C RCmConnectionMethod RCmManager::CreateConnectionMethodL(

        TUint32 aBearerType )

    {

    OstTraceFunctionEntry0( RCMMANAGER_CREATECONNECTIONMETHODL_ENTRY );

    if ( !iCmManagerApi )

        {

        User::Leave( KErrBadHandle );

        }

    CCmConnectionMethodWrapper* cmWrapper = CCmConnectionMethodWrapper::NewLC();

    cmWrapper->CreateConnMethodL( iCmManagerApi, aBearerType );

    CleanupStack::Pop( cmWrapper );

    RCmConnectionMethod cm;

    cm.iCmConnectionMethodWrapper = cmWrapper;

    OstTraceFunctionExit0( RCMMANAGER_CREATECONNECTIONMETHODL_EXIT );

    return cm;

    }

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

//  RCmManager::CopyConnectionMethodL()

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

//

EXPORT_C TInt RCmManager::CopyConnectionMethodL(

        RCmDestination& aTargetDestination,

        RCmConnectionMethod& aConnectionMethod )

    {

    OstTraceFunctionEntry0( RCMMANAGER_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( RCMMANAGER_COPYCONNECTIONMETHODL_EXIT );

    return index;

    }

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

//  RCmManager::MoveConnectionMethodL()

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

//

EXPORT_C TInt RCmManager::MoveConnectionMethodL(

        RCmDestination& aSourceDestination,

        RCmDestination& aTargetDestination,

        RCmConnectionMethod& aConnectionMethod )

    {

    OstTraceFunctionEntry0( RCMMANAGER_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( RCMMANAGER_MOVECONNECTIONMETHODL_EXIT );

    return pkgData.iIndex;

    }

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

//  RCmManager::RemoveConnectionMethodL()

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

//

EXPORT_C void RCmManager::RemoveConnectionMethodL(

        RCmDestination& aDestination,

        RCmConnectionMethod& aConnectionMethod )

    {

    OstTraceFunctionEntry0( RCMMANAGER_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();