/*
* ============================================================================
*  Name     : CIAPConnectDemoConnectionMonitor from 
*			IAPConnectDemoConnectionMonitor.cpp
*  Part of  : Internet Access Points Example v2.0
*  Created  : 01.09.2006 by Forum Nokia
*  Version  : 2.0
*  Copyright: Forum Nokia
* ============================================================================
*/

// INCLUDE FILES
#include <e32std.h>
#include <eikgted.h>
#include <cdbcols.h>
#include <commdb.h>
#include <es_sock.h>
#include <eikenv.h>
#include <commdbconnpref.h>
#include <IAPConnect.rsg>
#include <es_enum.h>	//subConnectionInfo

#include "IAPConnectDemoConnectionMonitor.h"
#include "IAPConnect.hrh"
#include "IAPConnectDemoSettings.h"

// CONSTANTS
const TInt KTextMaxLength = 50;
const TInt KTimeOut = 30000000; // 30 seconds time-out
const TInt KDemoIap = -10;
const TInt KMaxInfoMsgLength = 20;
_LIT(KTimeInfo, " minutes");
_LIT(KDataInfo, " bytes");
_LIT(KErrorMsg, "Error: ");
 
// ================= MEMBER FUNCTIONS =======================

// Constructor
CIAPConnectDemoConnectionMonitor::CIAPConnectDemoConnectionMonitor(
	MIAPConnectDemoConnectionMonitorObserver& aObserver): 
        CActive(EPriorityStandard), iObserver(aObserver), 
        iEngineStatus(EStopped), iSubconnectionIndex(1), iConnectionIndex(1)
	{
		
	}

// Destructor
CIAPConnectDemoConnectionMonitor::~CIAPConnectDemoConnectionMonitor()
	{
	//Could be used to close active connections even if other
	//applications are still using them.
	//iMonitor.SetBoolAttribute(0,0,KConnectionStopAll, ETrue);
	
    if (iConnections)
        {
    	iConnections -> Reset();
    	delete iConnections;
        iConnections = NULL;
        }
	iMonitor.Close();
	}

// ----------------------------------------------------
// CIAPConnectDemoConnectionMonitor::NewL()
//
// ----------------------------------------------------
//
CIAPConnectDemoConnectionMonitor* CIAPConnectDemoConnectionMonitor::NewL(
	MIAPConnectDemoConnectionMonitorObserver& aObserver)
	{
	CIAPConnectDemoConnectionMonitor* self = 
		CIAPConnectDemoConnectionMonitor::NewLC( aObserver );
	CleanupStack::Pop(self);
	return self;
	}

// ----------------------------------------------------
// CIAPConnectDemoConnectionMonitor::NewLC()
//
// ----------------------------------------------------
//	
CIAPConnectDemoConnectionMonitor* CIAPConnectDemoConnectionMonitor::NewLC(
	MIAPConnectDemoConnectionMonitorObserver& aObserver)
	{
	CIAPConnectDemoConnectionMonitor* self = 
		new (ELeave) CIAPConnectDemoConnectionMonitor( aObserver );
	CleanupStack::PushL( self );
	self -> ConstructL();
	return self;	
	}

// ---------------------------------------------------------
// CIAPConnectDemoConnectionMonitor::ConstructL()
// Symbian two-phased constructor
// ---------------------------------------------------------
//	
void CIAPConnectDemoConnectionMonitor::ConstructL()
	{
	TInt count = 1;
	iConnections = new (ELeave)CArrayFixSeg<TConnectionElement>( count );
	User::LeaveIfError( iMonitor.ConnectL() );
	CActiveScheduler::Add(this);
	}

	
// ---------------------------------------------------------
// CIAPConnectDemoConnectionMonitor::DoCancel()
// Implements cancellation of an outstanding request.
// Handles an active object抯 request completion event
// ---------------------------------------------------------
//	
void CIAPConnectDemoConnectionMonitor::DoCancel()
	{
	iMonitor.CancelNotifications();   
	}

// ---------------------------------------------------------
// CIAPConnectDemoConnectionMonitor::RunL()
// Handles an active object抯 request completion event.
// ---------------------------------------------------------
//	
void CIAPConnectDemoConnectionMonitor::RunL()
	{
	if (iStatus == KErrNone)
		{
		TBuf<KMaxInfoMsgLength> text;
		switch (iEngineStatus) 
			{
			case EConnectionCount:
			case EIapName:
				{
				// An empty event is added to to list				
				if ( iEngineStatus == EIapName )
					{
					//Add connections' information to the list for accounting
					TConnectionElement elem;
					elem.iConnectionId = iConnectionId;
					elem.iSubConnectionId = iSubconnectionId;
					iConnections -> AppendL( elem );		
					}
				if ( iConnectionIndex <= iConnectionCount )
					{
					
					//Find all connections and subconnections
					TUint connectionId = 0; 
					TUint subConnectionCount = 0;
					iMonitor.GetConnectionInfo( iConnectionIndex, 
                        connectionId, subConnectionCount);
					//if there is subconnections, first get connection info
					if (subConnectionCount >= 1 && iSubconnectionIndex == 0)
						{
						iMonitor.GetStringAttribute(connectionId, 0, 
                            KIAPName, iAttributeValue, iStatus);
						iSubconnectionIndex = 1;	
						}	
					else
						{
						// 0 is code for first loop and it must be
						// changed to 1 before calling info functions 
						if (iSubconnectionIndex == 0)
							iSubconnectionIndex = 1;
						
						TUint subConnectionId = 0;		
						iMonitor.GetSubConnectionInfo( connectionId, 
                            iSubconnectionIndex, subConnectionId );

						iConnectionId = connectionId;
						iSubconnectionId = subConnectionId;
						
						iMonitor.GetStringAttribute(connectionId, 
                            subConnectionId, KIAPName, iAttributeValue, iStatus);
								
						if ( iSubconnectionIndex >= subConnectionCount)
							{
							iSubconnectionIndex = 0;
							++iConnectionIndex;			
							}
						else
							{
							++iSubconnectionIndex ;
							}	
						}
						
					iEngineStatus = EIapName;								
					SetActive();
					}
				else
					{
					iEngineStatus = EStopped;
					}
				break;
			}
			case EStartTime:
				{
				TTime now;
				now.UniversalTime();
			
				TTime startTime = iStartTimePckg();
									
				//Calculate connection time 
				TTimeIntervalMinutes interval;
				TInt err = now.MinutesFrom( startTime, interval );
			
				if ( err == KErrNone)
					{
					text.AppendNum( interval.Int() );
					text.Append( KTimeInfo );	
					}
				else
					{
					text.Append( KErrorMsg );
					text.AppendNum( KErrOverflow );
					}
				iObserver.ShowInfoL( text );  // Show the connection time
				break;
				}
			//In both cases the code is exactly same
			case EUplinkData:
			case EDownlinkData:
				{
				text.AppendNum( iDataTransfer );
				text.Append( KDataInfo );
				iObserver.ShowInfoL( text );
				break;	
				}
			default:
				break;
			}
		
		}
	else
		{
    	// Nothing to do
		}
	}

// ---------------------------------------------------------
// CIAPConnectDemoConnectionMonitor::GetActiveConnections()
// Iniates the active connection search.
// ---------------------------------------------------------
//	
void CIAPConnectDemoConnectionMonitor::GetActiveConnections()
	{
	if (IsActive())
		{
		return;
		}
		
	//First must get connections count
	iMonitor.GetConnectionCount( iConnectionCount, iStatus );
	
	iConnections -> Reset();
	
	iSubconnectionIndex = 0;
	iConnectionIndex = 1;
	
	iEngineStatus = EConnectionCount;
	SetActive();		
	}
 
// ---------------------------------------------------------
// CIAPConnectDemoConnectionMonitor::CloseConnection()
// Closes a connection.
// ---------------------------------------------------------
//	
TBool CIAPConnectDemoConnectionMonitor::CloseConnection(const TInt& aIndex )
	{
	//Close connection if index is valid
	if (aIndex >= 0 && aIndex < iConnections -> Count())
		{
		TConnectionElement elem = iConnections -> At(aIndex);
		iMonitor.SetBoolAttribute(elem.iConnectionId,
									elem.iSubConnectionId,  
									KConnectionStop, ETrue);
		return ETrue;
		}
	else
		{
		return EFalse;						
		}
	 }

// ---------------------------------------------------------
// CIAPConnectDemoConnectionMonitor::GetInfo()
// Gets information about a connection.
// ---------------------------------------------------------
//		 
TBool CIAPConnectDemoConnectionMonitor::GetInfo(const TInt& aIndex, 
    const TMonitorState& aType)
	{
		if (IsActive())
			{
			return EFalse;
			}
			
		if (aIndex >= 0 && aIndex < iConnections -> Count())
		{
		//Get connection information, uses asynchronous callback functions
		switch ( aType )
			{
			case EConnectionTime:
				{
				TConnectionElement elem = iConnections -> At(aIndex);
				iMonitor.GetPckgAttribute(elem.iConnectionId,
										elem.iSubConnectionId,  
										KStartTime, iStartTimePckg , iStatus);
				iEngineStatus = EStartTime;
				SetActive();
				break;
				}
			case EDownlinkData:
				{
				TConnectionElement elem = iConnections -> At(aIndex);
				iMonitor.GetUintAttribute(elem.iConnectionId,
										elem.iSubConnectionId,  
										KDownlinkData, iDataTransfer, iStatus);
				iEngineStatus = EDownlinkData;
				SetActive();
				break;
				}
			case EUplinkData:
				{

				TConnectionElement elem = iConnections -> At(aIndex);
				iMonitor.GetUintAttribute(elem.iConnectionId,
										elem.iSubConnectionId,  
										KUplinkData, iDataTransfer , iStatus);
				iEngineStatus = EUplinkData;
				SetActive();
				break;
				}						
			default:
				{
				break;	
				}
			}
		return ETrue;
		}
	else
		{
		return EFalse;						
		}
	}
	
// End of file