/*
* Copyright (c) 2006-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: ?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)
{
iMonitorObserver->IRNetworkEventL(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;
if(iMonitoringRequired)
{
// Intimate the connection established event
iMonitorObserver->IRNetworkEventL(
ENetworkConnectionEstablished);
}
}
break;
case EBearerEdgeGPRS:
{
iIRConnectionType = EEdge;
if(iMonitoringRequired)
{
// Intimate the connection established event
iMonitorObserver->IRNetworkEventL(
ENetworkConnectionEstablished);
}
}
break;
case EBearerWLAN:
{
iIRConnectionType = EWiFi;
if(iMonitoringRequired)
{
// Intimate the connection established event
iMonitorObserver->IRNetworkEventL(
ENetworkConnectionEstablished);
}
}
break;
case EBearerWCDMA:
{
iIRConnectionType = EWcdma;
if(iMonitoringRequired)
{
// Intimate the connection established event
iMonitorObserver->IRNetworkEventL(
ENetworkConnectionEstablished);
}
}
break;
case EBearerCDMA2000:
{
iIRConnectionType = ECdma2000;
if(iMonitoringRequired)
{
// Intimate the connection established event
iMonitorObserver->IRNetworkEventL(
ENetworkConnectionEstablished);
}
}
break;
default:
{
#ifdef __WINS__
iIRConnectionType = EGprs;
if(iMonitoringRequired)
{
// Intimate the connection established event
iMonitorObserver->IRNetworkEventL(
ENetworkConnectionEstablished);
}
#endif
}
break;
}
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" );
}