/*
* Copyright (c) 2007 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:
*
*/
#include "irdebug.h"
#include "irnetworkobserver.h"
#include "irnetworkcontroller.h"
// ---------------------------------------------------------------------------
// CIRNetworkObserver::NewL
// Creates an Instance of CIRNetworkObserver
// ---------------------------------------------------------------------------
//
EXPORT_C CIRNetworkObserver *CIRNetworkObserver::NewL(
CIRNetworkController* aNetworkController )
{
IRLOG_DEBUG( "CIRNetworkObserver::NewL - Entering" );
CIRNetworkObserver *self = NewLC( aNetworkController );
CleanupStack::Pop( self );
IRLOG_DEBUG( "CIRNetworkObserver::NewL - Exiting." );
return self;
}
// ---------------------------------------------------------------------------
// CIRNetworkObserver::~CIRNetworkObserver()
// Default Destructor
// ---------------------------------------------------------------------------
//
CIRNetworkObserver::~CIRNetworkObserver()
{
IRLOG_DEBUG( "CIRNetworkObserver::~CIRNetworkObserver - Entering" );
Cancel();
iIRConnectionMonitor.CancelNotifications();
iIRConnectionMonitor.Close();
IRLOG_DEBUG( "CIRNetworkObserver::~CIRNetworkObserver - Exiting." );
}
// ---------------------------------------------------------------------------
// CIRNetworkObserver::InitializeNetworkObserver()
// Initializes the Connection monitor
// ---------------------------------------------------------------------------
//
void CIRNetworkObserver::InitializeNetworkObserver()
{
IRLOG_DEBUG( "CIRNetworkObserver::InitializeNetworkObserver - Entering" );
iConnectionId = 0;
if ( !IsActive() )
{
iObserverState = EInitializing;
iIRConnectionMonitor.GetConnectionCount( iConnectionCount,iStatus );
SetActive();
}
IRLOG_DEBUG( "CIRNetworkObserver::InitializeNetworkObserver - Exiting." );
}
// ---------------------------------------------------------------------------
// CIRNetworkObserver::SetObserver( MIRNetworkController* aObserver )
// Set the observer used to communicate with the IRNetworkController
// ---------------------------------------------------------------------------
//
void CIRNetworkObserver::SetObserver( MIRNetworkController* aObserver )
{
IRLOG_DEBUG( "CIRNetworkObserver::SetObserver - Entering" );
iMonitorObserver = aObserver;
iMonitoringRequired = ETrue;
IRLOG_DEBUG( "CIRNetworkObserver::SetObserver - Exiting." );
}
// ---------------------------------------------------------------------------
// CIRNetworkObserver::CIRNetworkObserver()
// Default Constructor
// ---------------------------------------------------------------------------
//
CIRNetworkObserver::CIRNetworkObserver( CIRNetworkController* aNetworkController ):
CActive( CActive::EPriorityStandard ), iNetworkController( aNetworkController )
{
IRLOG_DEBUG( "CIRNetworkObserver::CIRNetworkObserver - Entering" );
// Add the AO to the ActiveScheduler
CActiveScheduler::Add( this );
IRLOG_DEBUG( "CIRNetworkObserver::CIRNetworkObserver - Exiting." );
}
// ---------------------------------------------------------------------------
// Creates an Instance of CIRNetworkObserver
// ---------------------------------------------------------------------------
//
CIRNetworkObserver *CIRNetworkObserver::NewLC(
CIRNetworkController* aNetworkController )
{
IRLOG_DEBUG( "CIRNetworkObserver::NewLC - Entering " );
CIRNetworkObserver *self = new( ELeave )CIRNetworkObserver(
aNetworkController );
CleanupStack::PushL( self );
self->ConstructL();
IRLOG_DEBUG( "CIRNetworkObserver::NewLC - Exiting." );
return self;
}
// ---------------------------------------------------------------------------
// CIRNetworkObserver::ConstructL()
// Second Phase construction.
// ---------------------------------------------------------------------------
//
void CIRNetworkObserver::ConstructL()
{
IRLOG_DEBUG( "CIRNetworkObserver::ConstructL - Entering" );
iIRConnectionMonitor.ConnectL();
iIRConnectionMonitor.NotifyEventL( *this );
iMonitoringRequired = EFalse;
IRLOG_DEBUG( "CIRNetworkObserver::ConstructL - Exiting." );
}
// ---------------------------------------------------------------------------
// CIRNetworkObserver::RunL()
// The function is called by the active scheduler when a request completion event occurs,
// ---------------------------------------------------------------------------
//
void CIRNetworkObserver::RunL()
{
IRLOG_DEBUG( "CIRNetworkObserver::RunL - Entering" );
IRNetworkObserverRunL();
IRLOG_DEBUG( "CIRNetworkObserver::RunL - Exiting" );
}
// ---------------------------------------------------------------------------
// CIRNetworkObserver::DoCancel()
// Cancels the pending requests on the CIRNetworkObserver Active object
// ---------------------------------------------------------------------------
//
void CIRNetworkObserver::DoCancel()
{
IRLOG_DEBUG( "CIRNetworkObserver::DoCancel" );
}
// ---------------------------------------------------------------------------
// CIRNetworkObserver::RunError()
// Handles a leave occurring in the request completion event handler RunL()
// ---------------------------------------------------------------------------
//
TInt CIRNetworkObserver::RunError( TInt /*aError*/ )
{
IRLOG_DEBUG( "CIRNetworkObserver::RunError" );
iNetworkController->ResetHandingOverConnection();
return KErrNone;
}
// ---------------------------------------------------------------------------
// CIRNetworkObserver::EventL( const CConnMonEventBase &aConnMonEvent )
// Derived from MConnectionMonitorObserver
// Implements the EventL method which is called when there is a network event
// ---------------------------------------------------------------------------
//
void CIRNetworkObserver::EventL(const CConnMonEventBase &aConnMonEvent)
{
IRLOG_INFO4( "CIRNetworkObserver::EventL - Event type %d for connection %d, iConnectionId=%d",
aConnMonEvent.EventType(), aConnMonEvent.ConnectionId(), iConnectionId );
switch(aConnMonEvent.EventType())
{
case EConnMonCreateConnection:
{
//Triggered when a new connection has been been created
// for future implementation
}
break;
case EConnMonDeleteConnection:
{
//Triggered when a connection has been been deleted.
if( aConnMonEvent.ConnectionId() == iConnectionId )
{
if(iMonitoringRequired)
{
if (iMonitorObserver)
{
iMonitorObserver->IRNetworkEventL(ENetworkConnectionDisconnected);
}
else
{
iNetworkController->NotifyActiveNetworkObserversL(ENetworkConnectionDisconnected);
}
}
}
}
break;
case EConnMonCreateSubConnection:
{
//Triggered when a new subconnection has been been created
// for future implementation
}
break;
case EConnMonDeleteSubConnection:
{
//Triggered when a subconnection has been been deleted
// for future implementation
}
break;
case EConnMonDownlinkDataThreshold:
{
// for future implementation
}
break;
case EConnMonUplinkDataThreshold:
{
// for future implementation
}
break;
case EConnMonNetworkStatusChange:
{
// for future implementation
}
break;
case EConnMonConnectionStatusChange:
{
//Triggered when the status of some connection changes.
// for future implementation
}
break;
case EConnMonConnectionActivityChange:
{
//Triggered when some connection changes from active to idle or vice versa
// for future implementation
}
break;
case EConnMonNetworkRegistrationChange:
{
// for future implementation
}
break;
case EConnMonBearerChange:
{
//Triggered when bearer type (GPRS / Edge GPRS / WCDMA) changes
// for future implementation
}
break;
case EConnMonSignalStrengthChange:
{
// for future implementation
}
break;
case EConnMonBearerAvailabilityChange:
{
//Triggered when the availability of some bearer changes
// for future implementation
}
break;
case EConnMonIapAvailabilityChange:
{
// for future implementation
}
break;
case EConnMonTransmitPowerChange:
{
// for future implementation
}
break;
default:
{
// no implementation
}
break;
}
IRLOG_DEBUG( "CIRNetworkObserver::EventL - Exiting." );
}
// ---------------------------------------------------------------------------
// CIRNetworkObserver::IdentifyConnection()
// Identifies the type of connection we have used to get connected to network
// ---------------------------------------------------------------------------
//
void CIRNetworkObserver::IdentifyConnection()
{
IRLOG_DEBUG( "CIRNetworkObserver::IdentifyConnection - Entering" );
if ( !IsActive() )
{
iObserverState = EGettingConnectionInfo;
iIRConnectionMonitor.GetConnectionInfo(
iConnectionCount,iConnectionId,iSubConnectionCount );
// O Indicates method applies to connection
iIRConnectionMonitor.GetIntAttribute(
iConnectionId,0,KBearer,iConnectionType,iStatus );
SetActive();
}
IRLOG_DEBUG( "CIRNetworkObserver::IdentifyConnection - Exiting." );
}
// ---------------------------------------------------------------------------
// CIRNetworkObserver::GetIAPId()
// Retrieves the IAP Id of the connection
// ---------------------------------------------------------------------------
//
void CIRNetworkObserver::GetAPId()
{
IRLOG_DEBUG( "CIRNetworkObserver::GetIAPId - Entering" );
if ( !IsActive() )
{
iObserverState = EGettingIAPId;
iIRConnectionMonitor.GetConnectionInfo(
iConnectionCount, iConnectionId, iSubConnectionCount );
// O in RConnectionMonitor::GetIntAttribute indicates method applies to connection
iIRConnectionMonitor.GetUintAttribute(
iConnectionId, 0, KIAPId, iIAPId, iStatus );
SetActive();
}
IRLOG_DEBUG( "CIRNetworkObserver::GetIAPId - Exiting." );
}
// ---------------------------------------------------------------------------
// CIRNetworkObserver::IRNetworkObserverRunL()
// Utility function used just to keep RunL() small
// ---------------------------------------------------------------------------
//
void CIRNetworkObserver::IRNetworkObserverRunL()
{
IRLOG_DEBUG( "CIRNetworkObserver::IRNetworkObserverRunL - Entering" );
switch(iObserverState)
{
case EInitializing:
{
if( iStatus.Int() == KErrNone )
{
// Initializing the Connection Monitor sucessful
IdentifyConnection();
}
else
{
// Error initializing the connection monitor
iNetworkController->ResetHandingOverConnection();
}
}
break;
case EGettingConnectionInfo:
{
if( iStatus.Int() == KErrNone )
{
iIsIAPIdAvailable = EFalse;
GetAPId();
}
else
{
// Error initializing the connection monitor
iNetworkController->ResetHandingOverConnection();
}
}
break;
case EGettingIAPId:
{
iIsIAPIdAvailable = ETrue;
switch(iConnectionType)
{
case EBearerGPRS:
{
iIRConnectionType = EGprs;
}
break;
case EBearerEdgeGPRS:
{
iIRConnectionType = EEdge;
}
break;
case EBearerWLAN:
{
iIRConnectionType = EWiFi;
}
break;
case EBearerWCDMA:
{
iIRConnectionType = EWcdma;
}
break;
case EBearerCDMA2000:
{
iIRConnectionType = ECdma2000;
}
break;
default:
{
#ifdef __WINS__
iIRConnectionType = EGprs;
#endif
}
break;
}
if (iMonitoringRequired)
{
if (iMonitorObserver)
{
// Intimate the connection established event
iMonitorObserver->IRNetworkEventL(ENetworkConnectionEstablished);
}
else
{
iNetworkController->NotifyActiveNetworkObserversL(ENetworkConnectionEstablished);
}
}
iNetworkController->ResetHandingOverConnection();
}
break;
default:
{
// no implementation
}
break;
}
IRLOG_DEBUG( "CIRNetworkObserver::IRNetworkObserverRunL - Exiting." );
}
// ---------------------------------------------------------------------------
// CIRNetworkObserver::SetNetworkMonitoring()
// Sets network monitoring observer to decide whether network monitoring is required.
// ---------------------------------------------------------------------------
//
void CIRNetworkObserver::SetNetworkMonitoring( TBool aValue )
{
IRLOG_DEBUG( "CIRNetworkObserver::SetNetworkMonitoring - Entering" );
iMonitoringRequired = aValue;
IRLOG_DEBUG( "CIRNetworkObserver::SetNetworkMonitoring - Exiting" );
}