/*
* Copyright (c) 2005 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: Connection manager
*
*/
// INCLUDE FILES
#include <in_sock.h>
#include <es_enum.h>
#include <f32file.h>
#include <flogger.h>
#include "msgconntimer.h"
#include "msgconnmanager.h"
// ================= MEMBER FUNCTIONS =======================
//
// ----------------------------------------------------------
// CMsgConnManager::CMsgConnManager
//
// ----------------------------------------------------------
//
CMsgConnManager::CMsgConnManager() : CActive( EPriorityUserInput + 2 ),
iProgressStarted( EFalse ),
iConnectionClosed( ETrue )
{
}
// ----------------------------------------------------------
// CMsgConnManager::NewL
//
// ----------------------------------------------------------
//
CMsgConnManager* CMsgConnManager::NewL( const TInt aAccessPoint )
{
CMsgConnManager* self = new ( ELeave ) CMsgConnManager();
CleanupStack::PushL( self );
self->ConstructL( aAccessPoint );
CleanupStack::Pop();
return self;
}
// ----------------------------------------------------------
// CMsgConnManager::ConstructL
//
// ----------------------------------------------------------
//
void CMsgConnManager::ConstructL( const TInt aAccessPoint )
{
DeleteLogFileL();
iAccessPointID = aAccessPoint;
iConnectionTimer = CMsgConnTimer::NewL();
iCommsDatabase = CCommsDatabase::NewL( EDatabaseTypeUnspecified );
User::LeaveIfError( iSocketSession.Connect() );
User::LeaveIfError( iConnection.Open( iSocketSession ) );
iConnectionClosed = EFalse;
iAccessPointSettings.SetIapId( aAccessPoint );
iAccessPointSettings.SetDialogPreference( ECommDbDialogPrefDoNotPrompt );
#ifdef _DEBUG
WriteToLog( _L8( "CONNMAN: LOGGING ENABLED" ) );
#endif
CActiveScheduler::Add( this );
}
// ----------------------------------------------------
// CMsgConnManager::~CMsgConnManager
//
// ----------------------------------------------------
//
CMsgConnManager::~CMsgConnManager()
{
#ifdef _DEBUG
WriteToLog( _L8( "CMsgConnManager::~CMsgConnManager(), Destructor." ) );
#endif
Cancel();
delete iCommsDatabase;
delete iConnectionTimer;
iConnection.Close();
iSocketSession.Close();
iEventSubscribers.Close();
}
// ----------------------------------------------------------
// CMsgConnManager::DeleteLogFileL
//
// ----------------------------------------------------------
//
void CMsgConnManager::DeleteLogFileL()
{
RFs session;
User::LeaveIfError( session.Connect() );
CFileMan* manager = CFileMan::NewL( session );
manager->Delete( _L("C:\\logs\\MsgConnMan\\*.*") );
session.Close();
delete manager;
manager = NULL;
}
// ---------------------------------------------------------
// CMsgConnManager::StartBearerObserver
//
// ---------------------------------------------------------
//
void CMsgConnManager::StartNetworkObserver()
{
#ifdef _DEBUG
WriteToLog( _L8( "CMsgConnManager::StartNetworkObserver() Closed: %d" ), iConnectionClosed );
#endif
#ifdef __WINS__
if( !iConnectionClosed )
{
iStatus = KRequestPending;
SetActive();
}
#else
if( !iConnectionClosed )
{
if( !IsActive() )
{
iStatus = KRequestPending;
iConnection.ProgressNotification( iProgressBuffer, iStatus );
SetActive();
}
}
#endif
}
// ---------------------------------------------------------
// CMsgConnManager::RunL()
//
// ---------------------------------------------------------
//
void CMsgConnManager::RunL()
{
#ifdef _DEBUG
WriteToLog( _L8( "CMsgConnManager::RunL(), iConnManStatus: %d iStatus: %d iStage: %d iError: %d" ),
iConnManStatus, iStatus.Int(), iProgressBuffer().iStage, iProgressBuffer().iError );
#endif
switch( iConnManStatus )
{
case EMsgConnManWaitingForStartComplete:
#ifdef _DEBUG
WriteToLog( _L8( " Current status is EMsgConnManWaitingForStartComplete." ) );
#endif
WatchConnectionOpening();
break;
case EMsgConnManWaitingForNotifications:
#ifdef _DEBUG
WriteToLog( _L8( " Current status is EMsgConnManWaitingForNotifications." ) );
#endif
WatchConnectionOpening();
break;
case EMsgConnManObservingAccessPoint:
#ifdef _DEBUG
WriteToLog( _L8( " Current status is EMsgConnManObservingAccessPoint." ) );
#endif
DetermineConnectionStatusL();
break;
case EMsgConnManBearerSuspended:
#ifdef _DEBUG
WriteToLog( _L8( " Current status is EMsgConnManBearerSuspended." ) );
#endif
DetermineConnectionStatusL();
break;
case EMsgConnManDisconnectingPrevious:
#ifdef _DEBUG
WriteToLog( _L8( " Timer expired, complete client's request." ) );
#endif
User::RequestComplete( iTimedCompleteStatus, KErrNone );
iConnManStatus = EMsgConnManIdle;
break;
case EMsgConnManIdle:
#ifdef _DEBUG
WriteToLog( _L8( " Idle, iStatus is %d." ), iStatus.Int() );
#endif
break;
default:
#ifdef _DEBUG
WriteToLog( _L8( " Default case, should not be here." ) );
#endif
break;
}
#ifdef _DEBUG
WriteToLog( _L8( " RunL() ends" ) );
#endif
}
// ----------------------------------------------------
// CMsgConnManager::WatchConnectionOpening()
//
// ----------------------------------------------------
//
void CMsgConnManager::WatchConnectionOpening()
{
#ifdef _DEBUG
WriteToLog( _L8( " CMsgConnManager::WatchConnectionOpening() - iProgressStarted: %d" ), iProgressStarted );
#endif
//Lets quit right away if it is an error
if( iStatus != KErrNone )
{
#ifdef _DEBUG
WriteToLog( _L8( " Something wrong, complete with error: %d." ), iStatus.Int() );
#endif
iConnectionTimer->Cancel();
if( iConnManStatus == EMsgConnManWaitingForNotifications )
iConnection.CancelProgressNotification();
iConnection.Close();
iConnectionClosed = ETrue;
User::RequestComplete( iClientStatus, iStatus.Int() );
iConnManStatus = EMsgConnManIdle;
}
else
{
if( iProgressStarted )
{
iLastConnectionStage = iProgressBuffer().iStage;
if( iLastConnectionStage == KLinkLayerOpen ) //we are done
{
#ifdef _DEBUG
WriteToLog( _L8( " Connected. Completing with KErrNone." ) );
#endif
iConnectionTimer->Cancel();
iConnManStatus = EMsgConnManObservingAccessPoint;
StartNetworkObserver();
User::RequestComplete( iClientStatus, KErrNone );
iProgressStarted = EFalse;
}
else
{
#ifdef _DEBUG
WriteToLog( _L8( " Keep on waiting for progress." ) );
#endif
IssueRequest();
}
}
else
{
#ifdef _DEBUG
WriteToLog( _L8( " Start complete, watch progress." ) );
#endif
if( iConnManStatus == EMsgConnManWaitingForStartComplete )
{
iProgressStarted = ETrue;
iConnManStatus = EMsgConnManWaitingForNotifications;
}
IssueRequest();
}
}
}
// ----------------------------------------------------
// CMsgConnManager::DetermineConnectionStatus()
//
// ----------------------------------------------------
//
void CMsgConnManager::DetermineConnectionStatusL()
{
#ifdef _DEBUG
WriteToLog( _L8( " CMsgConnManager::DetermineConnectionStatus()" ) );
#endif
#ifdef __WINS__
Cancel();
switch( iStatus.Int() )
#else
switch( iProgressBuffer().iStage )
#endif
{
case KLinkLayerClosed:
case KConnectionUninitialised:
#ifdef _DEBUG
CMsgConnManager::WriteToLog( _L8( " KLinkLayerClosed, notify clients of EMsgBearerLost" ) );
#endif
Cancel();
iConnManStatus = EMsgConnManBearerLost;
BroadcastBearerEventL( EMsgBearerLost );
iConnection.Close();
iConnectionClosed = ETrue;
iEventSubscribers.Reset();
iConnManStatus = EMsgConnManIdle;
break;
case KLinkLayerOpen:
#ifdef _DEBUG
WriteToLog( _L8( " KLinkLayerOpen -> GPRS Context Active." ) );
#endif
if( iConnManStatus == EMsgConnManBearerSuspended )
{
#ifdef _DEBUG
WriteToLog( _L8( " Moving to active state." ) );
#endif
iConnManStatus = EMsgConnManObservingAccessPoint;
BroadcastBearerEventL( EMsgBearerActive );
StartNetworkObserver();
}
break;
case KDataTransferTemporarilyBlocked:
#ifdef _DEBUG
WriteToLog( _L8( " KDataTransferTemporarilyBlocked -> GPRS Context Suspended." ) );
#endif
if( iConnManStatus != EMsgConnManBearerSuspended )
{
#ifdef _DEBUG
WriteToLog( _L8( " Moving to suspended state." ) );
#endif
iConnManStatus = EMsgConnManBearerSuspended;
BroadcastBearerEventL( EMsgBearerSuspended );
}
StartNetworkObserver();
break;
default:
#ifdef _DEBUG
#ifdef __WINS__
if( iStatus.Int() == KErrCancel )
WriteToLog( _L8( " Bearer event generation cancelled" ) );
else
WriteToLog( _L8( " Some weird status: %d" ), iStatus.Int() );
#else
WriteToLog( _L8( " Default case! WTF?!?" ) );
#endif
#endif
StartNetworkObserver();
break;
}
}
// ---------------------------------------------------------
// CMsgConnManager::CancelStartL
//
// ---------------------------------------------------------
//
void CMsgConnManager::CancelStartL()
{
#ifdef _DEBUG
WriteToLog( _L8( "CMsgConnManager::CancelStartL()" ) );
#endif
if( iClientStatus != NULL && iClientStatus->Int() == KRequestPending )
{
if( iConnManStatus == EMsgConnManWaitingForStartComplete ||
iConnManStatus == EMsgConnManWaitingForNotifications )
{
Cancel();
iEventSubscribers.Reset();
User::RequestComplete( iClientStatus, KErrCancel );
iConnManStatus = EMsgConnManIdle;
iConnectionClosed = ETrue;
}
else User::Leave( KErrAbort );
}
else User::Leave( KErrAbort );
}
// ---------------------------------------------------------
// CMsgConnManager::StopConnection
//
// ---------------------------------------------------------
//
void CMsgConnManager::StopConnection()
{
#ifdef _DEBUG
WriteToLog( _L8( "CMsgConnManager::StopConnection()" ) );
#endif
if( iConnManStatus == EMsgConnManWaitingForStartComplete ||
iConnManStatus == EMsgConnManWaitingForNotifications ||
iConnManStatus == EMsgConnManIdle )
{
#ifdef _DEBUG
WriteToLog( _L8( " Status is %d, wrong state for this operation. Abort." ), iConnManStatus );
#endif
}
else
{
//If bearer has been lost, we're already closed
if( iConnManStatus != EMsgConnManBearerLost )
{
Cancel();
iConnection.Close();
iConnectionClosed = ETrue;
iEventSubscribers.Reset();
iConnManStatus = EMsgConnManIdle;
}
}
#ifdef _DEBUG
WriteToLog( _L8( " StopConnection() ends." ) );
#endif
}
// ---------------------------------------------------------
// CMsgConnManager::StopConnection
//
// ---------------------------------------------------------
//
void CMsgConnManager::StopConnection( TRequestStatus& aStatus )
{
#ifdef _DEBUG
WriteToLog( _L8( "CImpsConnectionManager::StopConnectionL()" ) );
#endif
aStatus = KRequestPending;
iClientStatus = &aStatus;
iTimedCompleteStatus = &aStatus;
if( iConnManStatus == EMsgConnManWaitingForStartComplete ||
iConnManStatus == EMsgConnManWaitingForNotifications ||
iConnManStatus == EMsgConnManDisconnectingPrevious ||
iConnManStatus == EMsgConnManIdle )
{
#ifdef _DEBUG
WriteToLog( _L8( " Status is %d, wrong state for this operation. Abort." ),
iConnManStatus );
#endif
User::RequestComplete( iClientStatus, KErrAbort );
}
else
{
//If bearer has been lost, we're already closed
if( iConnManStatus != EMsgConnManBearerLost )
{
Cancel();
iConnection.Close();
iConnectionClosed = ETrue;
iEventSubscribers.Reset();
iConnectionTimer->ActivateTimer( iStatus, 4000000 );
iConnManStatus = EMsgConnManDisconnectingPrevious;
SetActive();
}
else
{
#ifdef _DEBUG
WriteToLog( _L8( " Bearer lost, nothing to do. Complete with KErrNone" ) );
#endif
User::RequestComplete( iClientStatus, KErrNone );
}
}
#ifdef _DEBUG
WriteToLog( _L8( " StopConnectionL() ends" ) );
#endif
}
// ----------------------------------------------------
// CMsgConnManager::BroadcastBearerEvent
//
// ----------------------------------------------------
//
void CMsgConnManager::BroadcastBearerEventL( const TMsgBearerEvent aBearerEvent )
{
#ifdef _DEBUG
WriteToLog( _L8( "CMsgConnManager::BroadcastBearerEvent" ) );
#endif
TInt subs = iEventSubscribers.Count();
#ifdef _DEBUG
WriteToLog( _L8( " %d clients subscribed." ), subs );
#endif
if( subs > 0 )
{
TBool empty = EFalse;
MMsgBearerObsCallback* client = NULL;
for( TInt i = 0;i < subs && !empty;i++ )
{
//Just in case:
//If a client has managed to remove a listener from the queue
//in the previous callback, "i" will index a bad handle.
subs = iEventSubscribers.Count();
if( subs > 0 && i < subs )
{
client = iEventSubscribers[i];
__ASSERT_ALWAYS( client != NULL, User::Panic( _L( "ObserverNULL!" ), 1 ) );
TInt error = iProgressBuffer().iError;
if( aBearerEvent == EMsgBearerLost )
{
#ifdef _DEBUG
TInt stage = iProgressBuffer().iStage;
WriteToLog( _L8( " Event is EMsgBearerLost" ) );
WriteToLog( _L8( " Stage: %d" ), stage );
WriteToLog( _L8( " Error: %d" ), error );
#endif
}
TBool authClose = error == KErrConnectionTerminated;
client->HandleBearerEventL( authClose, aBearerEvent );
#ifdef _DEBUG
WriteToLog( _L8(" Client no. %d serviced" ), i );
#endif
}
else
{
#ifdef _DEBUG
WriteToLog( _L8(
" An event listener was removed inside the callback!" ) );
#endif
//Leave the for loop
empty = ETrue;
}
}
}
#ifdef _DEBUG
WriteToLog( _L8( " BroadcastBearerEvent() ends" ) );
#endif
}
// ----------------------------------------------------
// CMsgConnManager::IssueRequest
//
// ----------------------------------------------------
//
void CMsgConnManager::IssueRequest()
{
#ifdef _DEBUG
WriteToLog( _L8( "CMsgConnManager::IssueRequest(), status: %d" ), IsActive() );
#endif
iStatus = KRequestPending;
iConnection.ProgressNotification( iProgressBuffer, iStatus );
SetActive();
}
// ---------------------------------------------------------
// CMsgConnManager::StartConnection
//
// ---------------------------------------------------------
//
void CMsgConnManager::StartConnection( TRequestStatus& aStatus )
{
#ifdef _DEBUG
WriteToLog( _L8( "CMsgConnManager::StartConnection() iConnManStatus: %d" ), iConnManStatus );
#endif
TInt error = 0;
aStatus = KRequestPending;
iClientStatus = &aStatus;
if( iConnectionClosed )
{
error = iConnection.Open( iSocketSession );
iConnectionClosed = EFalse;
}
TBool exists = EFalse;
TNifProgress progress;
error = iConnection.Progress( progress );
#ifdef _DEBUG
WriteToLog( _L8( " Connection stage: %d error: %d" ), progress.iStage, error );
#endif
TRAPD( err, exists = IsValidApL( iAccessPointID ) );
if( ( error == KErrNone && err == KErrNone ) && exists )
{
if( progress.iStage == KConnectionUninitialised )
HandleNewConnection();
else
HandleExistingConnection();
}
else
{
#ifdef _DEBUG
WriteToLog( _L8( " Something's wrong, complete with KErrUnknown. IAP exists: %d Error: %d Err: %d" ), exists, error, err );
#endif
User::RequestComplete( iClientStatus, KErrUnknown );
iConnectionClosed = ETrue;
}
}
// ---------------------------------------------------------
// CMsgConnManager::HandleNewConnection
//
// ---------------------------------------------------------
//
void CMsgConnManager::HandleNewConnection()
{
#ifdef _DEBUG
WriteToLog( _L8( " CMsgConnManager::HandleNewConnection()" ) );
#endif
switch( iConnManStatus )
{
case EMsgConnManIdle:
#ifdef _DEBUG
WriteToLog( _L8( " Current status is EMsgConnManIdle," ) );
WriteToLog( _L8( " starting to connect IAP: %d" ), iAccessPointSettings.IapId() );
#endif
iLastConnectionStage = KConnectionUninitialised;
iConnection.Start( iAccessPointSettings, iStatus );
iConnManStatus = EMsgConnManWaitingForStartComplete;
iConnectionTimer->ActivateTimer( this, 20000000 );
SetActive();
break;
case EMsgConnManDisconnectingPrevious:
#ifdef _DEBUG
WriteToLog( _L8( " Current status is EMsgConnManDisconnectingPrevious," ) );
WriteToLog( _L8( " new connection cannot be started, ignore." ) );
#endif
User::RequestComplete( iClientStatus, KErrNotReady );
break;
default:
#ifdef _DEBUG
WriteToLog( _L8( " We're in some weird state, complete with KErrUnknown" ) );
#endif
User::RequestComplete( iClientStatus, KErrUnknown );
iConnManStatus = EMsgConnManIdle;
break;
}
}
// ---------------------------------------------------------
// CMsgConnManager::HandleExistingConnection
//
// ---------------------------------------------------------
//
void CMsgConnManager::HandleExistingConnection()
{
#ifdef _DEBUG
WriteToLog( _L8( " CMsgConnManager::HandleOldConnection()" ) );
#endif
switch( iConnManStatus )
{
case EMsgConnManDisconnectingPrevious:
#ifdef _DEBUG
WriteToLog( _L8( " Current status is EMsgConnManDisconnectingPrevious," ) );
WriteToLog( _L8( " attempting to open a connection while previous one is still disconnecting. Complete with KErrNotReady." ) );
#endif
User::RequestComplete( iClientStatus, KErrNotReady );
break;
case EMsgConnManObservingAccessPoint:
#ifdef _DEBUG
WriteToLog( _L8( " Current status is EMsgConnManObservingAccessPoint," ) );
WriteToLog( _L8( " already connected" ) );
#endif
User::RequestComplete( iClientStatus, KErrNone );
break;
case EMsgConnManWaitingForStartComplete:
case EMsgConnManWaitingForNotifications:
#ifdef _DEBUG
WriteToLog( _L8( " Already connecting, ignore" ) );
#endif
User::RequestComplete( iClientStatus, KErrAlreadyExists );
break;
default:
#ifdef _DEBUG
WriteToLog( _L8( " Unknown state, complete with KErrUnknown." ) );
#endif
User::RequestComplete( iClientStatus, KErrUnknown );
}
}
// ---------------------------------------------------------
// CMsgConnManager::HandleTimerEventL
//
// ---------------------------------------------------------
//
void CMsgConnManager::HandleTimerEvent( TInt /*aStatus*/ )
{
#ifdef _DEBUG
WriteToLog( _L8( "CMsgConnManager::HandleTimerEventL()" ) );
#endif
switch( iConnManStatus )
{
case EMsgConnManWaitingForNotifications:
case EMsgConnManWaitingForStartComplete:
Cancel();
#ifdef _DEBUG
WriteToLog( _L8( " Connection initiation timed out, complete with error KErrTimedOut" ) );
#endif
User::RequestComplete( iClientStatus, KErrTimedOut );
iConnection.Close();
iConnectionClosed = ETrue;
iConnManStatus = EMsgConnManIdle;
break;
default:
#ifdef _DEBUG
WriteToLog( _L8( " Default case, problems..." ) );
#endif
break;
}
}
// ---------------------------------------------------------
// CMsgConnManager::AddEventSubscriberL
//
// ---------------------------------------------------------
//
void CMsgConnManager::AddEventSubscriberL( MMsgBearerObsCallback* aClient )
{
#ifdef _DEBUG
WriteToLog( _L8( "CMsgConnManager::AddEventSubscriberL()" ) );
#endif
if( iEventSubscribers.Count() < KMaxNumberOfSubscribers )
User::LeaveIfError( iEventSubscribers.Append( aClient ) );
else
{
#ifdef _DEBUG
WriteToLog( _L8( " Not allowed to have more than %d clients" ), KMaxNumberOfSubscribers );
#endif
User::Leave( KErrAlreadyExists );
}
}
// ---------------------------------------------------------
// CMsgConnManager::RemoveEventSubscriber
//
// ---------------------------------------------------------
//
void CMsgConnManager::RemoveEventSubscriber( MMsgBearerObsCallback* aClient )
{
#ifdef _DEBUG
WriteToLog( _L8( "CMsgConnManager::RemoveEventSubscriber()" ) );
#endif
TInt index = iEventSubscribers.Find( aClient );
if( index >= 0 )
{
iEventSubscribers.Remove( index );
}
}
#ifdef _DEBUG
// ----------------------------------------------------
// CMsgConnManager::WriteToLog
//
// ----------------------------------------------------
//
void CMsgConnManager::WriteToLog( TRefByValue<const TDesC8> aFmt,... )
{
VA_LIST list;
VA_START( list, aFmt );
TBuf8<KConnManLogBufferMaxSize> buf;
buf.FormatList( aFmt, list );
RDebug::RawPrint( buf );
RFileLogger::Write( KConnManLogDir, KConnManLogFile, EFileLoggingModeAppend, buf );
}
#endif
// ----------------------------------------------------
// CMsgConnManager::SetAccessPointIDL
//
// ----------------------------------------------------
//
void CMsgConnManager::SetAccessPointIDL( const TInt aAccessPointID )
{
#ifdef _DEBUG
WriteToLog( _L8( "CMsgConnManager::SetAccessPointIDL: %d" ), aAccessPointID );
#endif
if( IsValidApL( aAccessPointID ) )
{
iAccessPointID = aAccessPointID;
iAccessPointSettings.SetIapId( iAccessPointID );
iAccessPointSettings.SetDialogPreference( ECommDbDialogPrefDoNotPrompt );
}
else
{
#ifdef _DEBUG
WriteToLog( _L8( " The specified AP does not exist, leaves with KErrNotFound" ) );
#endif
User::Leave( KErrNotFound );
}
}
// ----------------------------------------------------
// CMsgConnManager::NumberOfActiveConns
//
// ----------------------------------------------------
//
TInt CMsgConnManager::NumberOfActiveConns()
{
TUint count = 0;
TInt error = KErrNone;
if( !iConnectionClosed )
{
error = iConnection.EnumerateConnections( count );
}
#ifdef _DEBUG
WriteToLog( _L8( "CMsgConnManager::NumberOfActiveConns() Conns: %d Error: %d" ), count, error );
#endif
return KErrNone == error ? count : error;
}
// ---------------------------------------------------------
// CMsgConnManager::ReadFromCommsDbLC
//
// ---------------------------------------------------------
//
HBufC* CMsgConnManager::ReadFromCommsDbLC( const TSupportedCommDbRecords aParameter )
{
#ifdef _DEBUG
WriteToLog( _L8( "CMsgConnManager::ReadFromCommsDbLC()" ) );
#endif
TPtrC dbRecord;
HBufC* value = NULL;
CCommsDbTableView* view = NULL;
TInt error = InitCommDbViewLC( dbRecord, view, aParameter );
if( error == KErrNone )
{
TDbColType colType;
TUint32 attribute = 0;
view->ReadTypeAttribL( dbRecord, colType, attribute );
switch( colType )
{
case EDbColBit:
break;
case EDbColUint32:
{
TUint32 intValue = 0;
_LIT( KProxyPort,"%d" );
view->ReadUintL( dbRecord, intValue );
value = HBufC::NewLC( sizeof( KProxyPort ) );
TPtr portPtr( value->Des() );
portPtr.Format( KProxyPort, intValue );
value->Des().Copy( portPtr );
}
break;
case EDbColText8:
break;
case EDbColText16:
break;
case EDbColLongText16:
value = view->ReadLongTextLC( dbRecord );
break;
default:
break;
}
if( value != NULL )
{
#ifdef _DEBUG
HBufC8* temp = HBufC8::NewL( value->Des().Length() );
TPtr8 ptr( temp->Des() );
ptr.Copy( *value );
WriteToLog( _L8( " Value was found: %S" ), &ptr );
delete temp;
temp = NULL;
#endif
CleanupStack::Pop(); //value
CleanupStack::PopAndDestroy(); //view
CleanupStack::PushL( value ); //Put it back in
}
else
{
#ifdef _DEBUG
WriteToLog( _L8( " No proxy address defined in CommDb" ) );
#endif
CleanupStack::PopAndDestroy(); //view
}
}
else
{
#ifdef _DEBUG
WriteToLog( _L8( " Error: %d" ), error );
#endif
}
return value;
}
// ---------------------------------------------------------
// CMsgConnManager::InitCommDbViewLC
//
// ---------------------------------------------------------
//
TInt CMsgConnManager::InitCommDbViewLC( TPtrC& aDbRecord,
CCommsDbTableView*& aView,
const TSupportedCommDbRecords aParameter )
{
#ifdef _DEBUG
WriteToLog( _L8( " CMsgConnManager::InitCommDbViewLC" ) );
#endif
aView = iCommsDatabase->OpenViewMatchingUintLC
( TPtrC( IAP ), TPtrC( COMMDB_ID ), iAccessPointID );
TInt error = aView->GotoFirstRecord();
if( error == KErrNone )
{
error = DetermineRecordTypeLC( aDbRecord, aView, aParameter );
#ifdef _DEBUG
if( error != KErrNone )
WriteToLog( _L8( " DetermineRecordType() failed - Error: %d" ), error );
#endif
}
else
{
#ifdef _DEBUG
WriteToLog( _L8( " No matching view found - Error: %d" ), error );
#endif
CleanupStack::PopAndDestroy(); //aView
aView = NULL;
}
return error;
}
// ---------------------------------------------------------
// CMsgConnManager::DetermineRecordType
//
// ---------------------------------------------------------
//
TInt CMsgConnManager::DetermineRecordTypeLC( TPtrC& aDbColumn,
CCommsDbTableView*& aView,
const TSupportedCommDbRecords aParameter )
{
#ifdef _DEBUG
WriteToLog( _L8( " CMsgConnManager::DetermineRecordType()" ) );
#endif
TInt error = KErrNotFound;
switch( aParameter )
{
case EMsgProxyAddress:
#ifdef _DEBUG
WriteToLog( _L8( " Type is EImpsProxyAddress" ) );
#endif
if( CheckProxyUsageLC( aView ) )
{
error = KErrNone;
aDbColumn.Set( TPtrC( PROXY_SERVER_NAME ) );
}
break;
case EMsgProxyPort:
#ifdef _DEBUG
WriteToLog( _L8( " Type is EImpsProxyPort" ) );
#endif
if( CheckProxyUsageLC( aView ) )
{
error = KErrNone;
aDbColumn.Set( TPtrC( PROXY_PORT_NUMBER ) );
}
break;
default:
#ifdef _DEBUG
WriteToLog( _L8( " Default case, problems..." ) );
#endif
error = KErrNotSupported;
break;
}
return error;
}
// ---------------------------------------------------------
// CMsgConnManager::CheckProxyUsageLC
//
// ---------------------------------------------------------
//
TBool CMsgConnManager::CheckProxyUsageLC( CCommsDbTableView*& aView )
{
#ifdef _DEBUG
WriteToLog( _L8( "CMsgConnManager::CheckProxyUsageL()" ) );
#endif
TBool useProxy = EFalse;
TUint32 serviceIdNumber = 0;
TBuf<KCommsDbSvrMaxFieldLength> serviceIdText;
aView->ReadTextL( TPtrC( IAP_SERVICE_TYPE ), serviceIdText );
aView->ReadUintL( TPtrC( IAP_SERVICE ), serviceIdNumber );
CleanupStack::PopAndDestroy(); //aView
aView = NULL;
aView = iCommsDatabase->OpenViewOnProxyRecordLC( serviceIdNumber, serviceIdText );
TInt error = aView->GotoFirstRecord();
if( error == KErrNone )
{
aView->ReadBoolL( TPtrC( PROXY_USE_PROXY_SERVER ), useProxy );
if( !useProxy )
{
CleanupStack::PopAndDestroy(); //aView
aView = NULL;
}
}
else
{
#ifdef _DEBUG
WriteToLog( _L8( " The AP does not use a proxy server." ) );
#endif
CleanupStack::PopAndDestroy(); //aView
aView = NULL;
}
return useProxy;
}
// ---------------------------------------------------------
// CMsgConnManager::IsValidApL
//
// ---------------------------------------------------------
//
TBool CMsgConnManager::IsValidApL( TUint32 aUid )
{
#ifdef _DEBUG
WriteToLog( _L8( "CMsgConnManager::IsValidApL()" ) );
#endif
CCommsDbTableView* table = iCommsDatabase->OpenViewMatchingUintLC( TPtrC( IAP ),
TPtrC( COMMDB_ID ),
aUid );
TInt res = table->GotoFirstRecord();
CleanupStack::PopAndDestroy(); // table
return res == KErrNone;
}
// ---------------------------------------------------------
// CMsgConnManager::DoCancel
//
// ---------------------------------------------------------
//
void CMsgConnManager::DoCancel()
{
#ifdef _DEBUG
WriteToLog( _L8( "CMsgConnManager::DoCancel()" ) );
#endif
switch( iConnManStatus )
{
case EMsgConnManWaitingForStartComplete:
#ifdef _DEBUG
WriteToLog( _L8( " Status is EMsgConnManWaitingForStartComplete" ) );
#endif
iConnection.Close();
iConnectionTimer->Cancel();
break;
case EMsgConnManWaitingForNotifications:
#ifdef _DEBUG
WriteToLog( _L8( " Status is EMsgConnManWaitingForNotifications" ) );
#endif
iConnection.CancelProgressNotification();
iConnectionTimer->Cancel();
iConnection.Close();
break;
case EMsgConnManDisconnectingPrevious:
#ifdef _DEBUG
WriteToLog( _L8( " Status is EMsgConnManDisconnectingPrevious" ) );
#endif
iConnectionTimer->Cancel();
User::RequestComplete( iClientStatus, KErrCancel );
#ifdef _DEBUG
WriteToLog( _L8( " StopConnection() terminated, client's request completed." ) );
#endif
break;
case EMsgConnManObservingAccessPoint:
case EMsgConnManBearerSuspended:
{
#ifdef _DEBUG
WriteToLog( _L8( " Status is %d" ), iConnManStatus );
#endif
iConnection.CancelProgressNotification();
#ifdef __WINS__
TRequestStatus* status = &iStatus;
User::RequestComplete( status, KErrCancel );
#endif
}
break;
case EMsgConnManIdle:
#ifdef _DEBUG
WriteToLog( _L8( " Status is EMsgConnManIdle" ) );
#endif
break;
default:
#ifdef _DEBUG
WriteToLog( _L8( " Default case" ) );
#endif
break;
}
}
// ----------------------------------------------------
// NewImpsConnManL
// Returns a ConnManager instance
// ----------------------------------------------------
//
EXPORT_C MMsgConnManager* NewMsgConnManagerL( const TInt aDefaultAccessPoint )
{
return CMsgConnManager::NewL( aDefaultAccessPoint );
}