/*
* 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();
TInt connMethodHandle = aConnectionMethod.iCmConnectionMethodWrapper->GetHandle();
TInt err = iCmManagerApi->RemoveConnectionMethod( targetDestHandle, connMethodHandle );
User::LeaveIfError( err );
OstTraceFunctionExit0( RCMMANAGER_REMOVECONNECTIONMETHODL_EXIT );
}
//-----------------------------------------------------------------------------
// RCmManager::RemoveAllReferencesL()
//-----------------------------------------------------------------------------
//
EXPORT_C void RCmManager::RemoveAllReferencesL(
RCmConnectionMethod& aConnectionMethod )
{
OstTraceFunctionEntry0( RCMMANAGER_REMOVEALLREFERENCESL_ENTRY );
if ( !iCmManagerApi )
{
User::Leave( KErrBadHandle );
}
if ( !aConnectionMethod.iCmConnectionMethodWrapper ||
!aConnectionMethod.iCmConnectionMethodWrapper->SessionConnected() )
{
User::Leave( KErrArgument );
}
TInt connMethodHandle = aConnectionMethod.iCmConnectionMethodWrapper->GetHandle();
TInt err = iCmManagerApi->RemoveAllReferences( connMethodHandle );
User::LeaveIfError( err );
OstTraceFunctionExit0( RCMMANAGER_REMOVEALLREFERENCESL_EXIT );
}
//-----------------------------------------------------------------------------
// RCmManager::ConnectionMethodL()
//-----------------------------------------------------------------------------
//
EXPORT_C void RCmManager::ConnectionMethodL(
RArray<TUint32>& aCmArray,
TBool aCheckBearerType,
TBool aLegacyOnly,
TBool aEasyWlan ) const
{
OstTraceFunctionEntry0( DUP1_RCMMANAGER_CONNECTIONMETHODL_ENTRY );
if ( !iCmManagerApi )
{
User::Leave( KErrBadHandle );
}
TCmmIpcStructGetConnMethods parameters;
parameters.iCheckBearerType = aCheckBearerType;
parameters.iLegacyOnly = aLegacyOnly;
parameters.iEasyWlan = aEasyWlan;
iCmManagerApi->GetConnMethodsL( parameters, aCmArray );
OstTraceFunctionExit0( RCMMANAGER_CONNECTIONMETHODL_EXIT );
}
//-----------------------------------------------------------------------------
// RCmManager::AllDestinationsL()
//-----------------------------------------------------------------------------
//
EXPORT_C void RCmManager::AllDestinationsL( RArray<TUint32>& aDestArray ) const
{
OstTraceFunctionEntry0( RCMMANAGER_ALLDESTINATIONSL_ENTRY );
if ( !iCmManagerApi )
{
User::Leave( KErrBadHandle );
}
iCmManagerApi->GetAllDestinationsL( aDestArray );
OstTraceFunctionExit0( RCMMANAGER_ALLDESTINATIONSL_EXIT );
}
//-----------------------------------------------------------------------------
// RCmManager::DestinationL()
//-----------------------------------------------------------------------------
//
EXPORT_C RCmDestination RCmManager::DestinationL( TUint32 aDestinationId ) const
{
OstTraceFunctionEntry0( RCMMANAGER_DESTINATIONL_ENTRY );
if ( !iCmManagerApi )
{
User::Leave( KErrBadHandle );
}
// If client already has a handle open to this destination, give a
// reference to it.
CCmDestinationWrapper* destWrap = CCmDestinationWrapper::NewLC();
TInt existingHandle( 0 );
destWrap->GetDestWithIdL( iCmManagerApi, aDestinationId, existingHandle );
if ( existingHandle )
{
CleanupStack::PopAndDestroy( destWrap );
destWrap = iCmManagerApi->GetDestinationWrapperL( existingHandle );
destWrap->IncreaseReferenceCounter();
}
else
{
CleanupStack::Pop( destWrap );
}
RCmDestination dest;
dest.iCmDestinationWrapper = destWrap;
return dest;
}
//-----------------------------------------------------------------------------
// RCmManager::BearerPriorityArrayL()
//-----------------------------------------------------------------------------
//
EXPORT_C void RCmManager::BearerPriorityArrayL(
RArray<TBearerPriority>& aArray ) const
{
OstTraceFunctionEntry0( RCMMANAGER_BEARERPRIORITYARRAYL_ENTRY );
if ( !iCmManagerApi )
{
User::Leave( KErrBadHandle );
}
iCmManagerApi->GetBearerPriorityArrayL( aArray );
OstTraceFunctionExit0( RCMMANAGER_BEARERPRIORITYARRAYL_EXIT );
}
//-----------------------------------------------------------------------------
// RCmManager::UpdateBearerPriorityArrayL()
//-----------------------------------------------------------------------------
//
EXPORT_C void RCmManager::UpdateBearerPriorityArrayL(
const RArray<TBearerPriority>& aArray )
{
OstTraceFunctionEntry0( RCMMANAGER_UPDATEBEARERPRIORITYARRAYL_ENTRY );
if ( !iCmManagerApi )
{
User::Leave( KErrBadHandle );
}
iCmManagerApi->SetBearerPriorityArrayL( aArray );
OstTraceFunctionExit0( RCMMANAGER_UPDATEBEARERPRIORITYARRAYL_EXIT );
}
//-----------------------------------------------------------------------------
// RCmManager::CleanupGlobalPriorityArray()
//-----------------------------------------------------------------------------
//
EXPORT_C void RCmManager::CleanupGlobalPriorityArray(
RArray<TBearerPriority>& aArray ) const
{
OstTraceFunctionEntry0( RCMMANAGER_CLEANUPGLOBALPRIORITYARRAY_ENTRY );
for ( TInt i = 0; i < aArray.Count(); i++ )
{
delete aArray[i].iServiceType;
}
aArray.Reset();
aArray.Close();
OstTraceFunctionExit0( RCMMANAGER_CLEANUPGLOBALPRIORITYARRAY_EXIT );
}
//-----------------------------------------------------------------------------
// RCmManager::SupportedBearersL()
//-----------------------------------------------------------------------------
//
EXPORT_C void RCmManager::SupportedBearersL( RArray<TUint32>& aArray ) const
{
OstTraceFunctionEntry0( RCMMANAGER_SUPPORTEDBEARERSL_ENTRY );
if ( !iCmManagerApi )
{
User::Leave( KErrBadHandle );
}
iCmManagerApi->GetSupportedBearersL( aArray );
OstTraceFunctionExit0( RCMMANAGER_SUPPORTEDBEARERSL_EXIT );
}
//-----------------------------------------------------------------------------
// RCmManager::EasyWlanIdL()
//-----------------------------------------------------------------------------
//
EXPORT_C TUint32 RCmManager::EasyWlanIdL() const
{
OstTraceFunctionEntry0( RCMMANAGER_EASYWLANIDL_ENTRY );
if ( !iCmManagerApi )
{
User::Leave( KErrBadHandle );
}
TUint32 value( 0 );
TInt err = iCmManagerApi->GetEasyWlanId( value );
User::LeaveIfError( err );
OstTraceFunctionExit0( RCMMANAGER_EASYWLANIDL_EXIT );
return value;
}
//-----------------------------------------------------------------------------
// RCmManager::ReadDefConnL()
//-----------------------------------------------------------------------------
//
EXPORT_C void RCmManager::ReadDefConnL(
TCmDefConnValue& aDefConnSetting )
{
OstTraceFunctionEntry0( RCMMANAGER_READDEFCONNL_ENTRY );
if ( !iCmManagerApi )
{
User::Leave( KErrBadHandle );
}
TInt err = iCmManagerApi->ReadDefaultConnection( aDefConnSetting );
User::LeaveIfError( err );
OstTraceFunctionExit0( RCMMANAGER_READDEFCONNL_EXIT );
}
//-----------------------------------------------------------------------------
// RCmManager::WriteDefConnL()
//-----------------------------------------------------------------------------
//
EXPORT_C void RCmManager::WriteDefConnL(
const TCmDefConnValue& aDefConnSetting )
{
OstTraceFunctionEntry0( RCMMANAGER_WRITEDEFCONNL_ENTRY );
if ( !iCmManagerApi )
{
User::Leave( KErrBadHandle );
}
TInt err = iCmManagerApi->WriteDefaultConnection( aDefConnSetting );
User::LeaveIfError( err );
OstTraceFunctionExit0( RCMMANAGER_WRITEDEFCONNL_EXIT );
}
//-----------------------------------------------------------------------------
// RCmManager::ReadGenConnSettingsL()
//-----------------------------------------------------------------------------
//
EXPORT_C void RCmManager::ReadGenConnSettingsL(
TCmGenConnSettings& aGenConnSettings )
{
OstTraceFunctionEntry0( RCMMANAGER_READGENCONNSETTINGSL_ENTRY );
if ( !iCmManagerApi )
{
User::Leave( KErrBadHandle );
}
TInt err = iCmManagerApi->ReadGeneralConnectionSettings( aGenConnSettings );
User::LeaveIfError( err );
OstTraceFunctionExit0( RCMMANAGER_READGENCONNSETTINGSL_EXIT );
}
//-----------------------------------------------------------------------------
// RCmManager::WriteGenConnSettingsL()
//-----------------------------------------------------------------------------
//
EXPORT_C void RCmManager::WriteGenConnSettingsL(
const TCmGenConnSettings& aGenConnSettings )
{
OstTraceFunctionEntry0( RCMMANAGER_WRITEGENCONNSETTINGSL_ENTRY );
if ( !iCmManagerApi )
{
User::Leave( KErrBadHandle );
}
TInt err = iCmManagerApi->WriteGeneralConnectionSettings( aGenConnSettings );
User::LeaveIfError( err );
OstTraceFunctionExit0( RCMMANAGER_WRITEGENCONNSETTINGSL_EXIT );
}
//-----------------------------------------------------------------------------
// RCmManager::CreateDestinationL()
//-----------------------------------------------------------------------------
//
EXPORT_C RCmDestination RCmManager::CreateDestinationL(
const TDesC& aName,
TUint32 aDestId )
{
OstTraceFunctionEntry0( DUP1_RCMMANAGER_CREATEDESTINATIONL_ENTRY );
if ( aDestId == 0 )
{
return CreateDestinationL( aName );
}
if ( !iCmManagerApi )
{
User::Leave( KErrBadHandle );
}
if ( aName.Length() == 0 )
{
User::Leave( KErrArgument );
}
TUint32 adjustedDestId( 0 );
if ( aDestId > KCmmDestIdIntervalLegacyMin && aDestId < KCmmDestIdIntervalLegacyMax )
{
adjustedDestId = aDestId + KCmDefaultDestinationAPTagId;
}
else if ( aDestId > KCmmDestIdIntervalMin && aDestId < KCmmDestIdIntervalMax )
{
adjustedDestId = aDestId;
}
else
{
User::Leave( KErrArgument );
}
CCmDestinationWrapper* destWrap = CCmDestinationWrapper::NewLC();
destWrap->CreateDestByNameAndIdL( iCmManagerApi, aName, adjustedDestId );
CleanupStack::Pop( destWrap );
RCmDestination dest;
dest.iCmDestinationWrapper = destWrap;
OstTraceFunctionExit0( DUP1_RCMMANAGER_CREATEDESTINATIONL_EXIT );
return dest;
}
//-----------------------------------------------------------------------------
// RCmManager::CreateConnectionMethodL()
//-----------------------------------------------------------------------------
//
EXPORT_C RCmConnectionMethod RCmManager::CreateConnectionMethodL(
TUint32 aBearerType,
TUint32 aConnMethodId )
{
OstTraceFunctionEntry0( DUP1_RCMMANAGER_CREATECONNECTIONMETHODL_ENTRY );
if ( aConnMethodId == 0 )
{
return CreateConnectionMethodL( aBearerType );
}
if ( !iCmManagerApi )
{
User::Leave( KErrBadHandle );
}
if ( !( aConnMethodId > KCmmConnMethodIdIntervalMin &&
aConnMethodId < KCmmConnMethodIdIntervalMax ) )
{
User::Leave( KErrArgument );
}
CCmConnectionMethodWrapper* cmWrapper = CCmConnectionMethodWrapper::NewLC();
cmWrapper->CreateConnMethodWithIdL( iCmManagerApi, aBearerType, aConnMethodId );
CleanupStack::Pop( cmWrapper );
RCmConnectionMethod cm;
cm.iCmConnectionMethodWrapper = cmWrapper;
OstTraceFunctionExit0( DUP1_RCMMANAGER_CREATECONNECTIONMETHODL_EXIT );
return cm;
}
//-----------------------------------------------------------------------------
// RCmManager::GetUncategorizedIconL()
//-----------------------------------------------------------------------------
//
EXPORT_C HBufC* RCmManager::GetUncategorizedIconL() const
{
OstTraceFunctionEntry0( RCMMANAGER_GETUNCATEGORIZEDICONL_ENTRY );
User::Leave( KErrNotSupported );
OstTraceFunctionExit0( RCMMANAGER_GETUNCATEGORIZEDICONL_EXIT );
return NULL;
}
// End of file