/*

* Copyright (c) 2008 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:  Monitors the network for availability and starts any pending

*                data sync sessions.

*

*/

// USER INCLUDES

#include "CNetMon.h"

// CONSTANTS

const TInt KValidInterrupt = -1;

const TInt KIntReset = 0;

//const TInt KStabilityTimeout = 5; // In seconds

const TInt KGlobalTimeout = 30; // In minutes

const TInt KNsmlDsAutoStartTimeoutKey = 3; // 0x0000003 defined in DS cenrep

const TInt KMicroSecond = 1000000;

const TInt KTimeUnit = 60;

const TUid KRepositoryId              = { 0x2000CF7E };

// ============================== MEMBER FUNCTIONS ============================

// ----------------------------------------------------------------------------

// CNetMon::NewL

// Two Phase Construction

// ----------------------------------------------------------------------------

CNetMon* CNetMon::NewL()

{

    DBG_FILE(_S8("CNetMon::NewL() begins"));

    CNetMon* self = new (ELeave) CNetMon;

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    DBG_FILE(_S8("CNetMon::NewL() ends"));

    return self;

}

// ----------------------------------------------------------------------------

// CNetMon::CNetMon

// Constructor

// ----------------------------------------------------------------------------

CNetMon::CNetMon() : CActive(CActive::EPriorityHigh)

{

    DBG_FILE(_S8("CNetMon::CNetMon() begins"));

	CActiveScheduler::Add(this);

    DBG_FILE(_S8("CNetMon::CNetMon() ends"));

}

// ----------------------------------------------------------------------------

// CNetMon::ConstructL

// Second phase constructor

// ----------------------------------------------------------------------------

void CNetMon::ConstructL()

{     

    DBG_FILE(_S8("CNetMon::ConstructL() begins"));

	iSyncSessionOpen = EFalse;

    iConMonBearerId = TConnMonBearerId(-1);

    iTimerCount = 0;

    iPrgPrevStatus = TStatus(-1);

	iPrgCurStatus = TStatus(-1);

    // Initial state

    iState = ERegister;

    IssueRequest();

    // Attach to sync status P&S keys    

	TInt err = iProperty.Attach(KPSUidDataSynchronizationInternalKeys, 

	                            KDataSyncStatus);

	User::LeaveIfError(err);

	iGlobalTimer = CPeriodic::NewL (EPriorityNormal) ;

	iGlobalTimeout = ReadTimeoutFromCenrepL();

	TInt timeout = KGlobalTimeout * KTimeUnit * KMicroSecond;

	iGlobalTimer->Start ( TTimeIntervalMicroSeconds32(timeout), 

	                      TTimeIntervalMicroSeconds32(timeout), 

	                      TCallBack(Timeout, this ) );		

    DBG_FILE(_S8("CNetMon::ConstructL() ends"));	

}

// ----------------------------------------------------------------------------

// CNetMon::~CNetMon

// Destructor*

// ----------------------------------------------------------------------------

CNetMon::~CNetMon()

{

	 DBG_FILE(_S8("CNetMon::~CNetMon() begins"));

	 DBG_FILE(_S8("CNetMon::~CNetMon() ends"));

}

// ----------------------------------------------------------------------------

// CNetMon::RunL

// ---------------------------------------------------------------------------

void CNetMon::RunL()

{

    switch ( iState ) 

    {

		case ERegister:

		    DBG_FILE(_S8("CNetMon::RunL() State = ERegister"));

		    RegisterL();

		    break;

		case EMonitor:

		    DBG_FILE(_S8("CNetMon::RunL() State = EMonitor"));

		    NetworkUp1();				 

		    // Wait for network up event

		    break;

        case ENetworkUp1:

            DBG_FILE(_S8("CNetMon::RunL() State = ENetworkUp1"));

            //InitTimerL();  

            NetworkUp2(this);          

            break;

		case ENetworkUp2:

			DBG_FILE(_S8("CNetMon::RunL() State = ENetworkUp2"));

		    OtherSyncStatus();

		    break;

    	case ESyncOk:

    		DBG_FILE(_S8("CNetMon::RunL() State = ESyncOk"));

    	    StartSyncL();

    	    break;

    	case EInitSync:

    		DBG_FILE(_S8("CNetMon::RunL() State = EInitSync"));

    	    // Wait for sync job to complete

    	    break;

		case EComplete:

			DBG_FILE(_S8("CNetMon::RunL() State = EComplete"));

		    Complete();

		    break;

		default:

		    break;

    }

}

// ----------------------------------------------------------------------------

// CNetMon::RunError

// ----------------------------------------------------------------------------

TInt CNetMon::RunError ( TInt aError )

{

    DBG_FILE_CODE(aError, _S8("CNetMon::RunError() The Error occurred is "));

    return KErrNone;

}

// ----------------------------------------------------------------------------

// CNetMon::DoCancel

// ----------------------------------------------------------------------------

void CNetMon::DoCancel()

{

	DBG_FILE(_S8("CNetMon::DoCancel() begins"));

	//CancelTimer();

	DBG_FILE(_S8("CNetMon::DoCancel() ends"));

}

// ----------------------------------------------------------------------------

// CNetMon::RegisterL

// ----------------------------------------------------------------------------

void CNetMon::RegisterL()

{

    DBG_FILE(_S8("CNetMon::RegisterL() begins"));

    // Register for events

    iConnectionMonitor.ConnectL();

    iConnectionMonitor.NotifyEventL(*this);      

    // Wait for events

    iState = EMonitor;

    IssueRequest();

    DBG_FILE(_S8("CNetMon::RegisterL() ends"));

}

// ----------------------------------------------------------------------------

// CNetMon::PacketDataAvailable

// ----------------------------------------------------------------------------

TBool CNetMon::PacketDataAvailable()

{

    DBG_FILE(_S8("CNetMon::PacketDataAvailable() begins"));

    TRequestStatus status;

    TBool val = EFalse;     

    if( iConMonBearerId != TConnMonBearerId(-1))

    {

    	 iConnectionMonitor.GetBoolAttribute(iConMonBearerId, 

					                         0,

					                         KPacketDataAvailability, 

					                         val,

					                         status );

    	User::WaitForRequest(status);			

    }

    else

    {

    	DBG_FILE(_S8("CNetMon::PacketDataAvailable() Invalid connection ID encountered"));

	    TRequestStatus gprsstatus;

		iConnectionMonitor.GetBoolAttribute(EBearerIdGPRS, 

						                   0, 

						                   KPacketDataAvailability, 

						                   val, 

						                   gprsstatus);

		User::WaitForRequest(gprsstatus);

		if(val == EFalse)

		{

			TRequestStatus wcdmastatus;

			iConnectionMonitor.GetBoolAttribute(EBearerIdWCDMA, 

							                   0, 

							                   KPacketDataAvailability, 

							                   val, 

							                   wcdmastatus);

			User::WaitForRequest(wcdmastatus);

			if(val != EFalse)

			{

				iConMonBearerId = EBearerIdWCDMA;

			}

		}

		else

			iConMonBearerId = EBearerIdGPRS;

    }

	DBG_FILE_CODE(iConMonBearerId, _S8("CNetMon::PacketDataAvailable() The Connection Id is"));   			

    DBG_FILE(_S8("CNetMon::PacketDataAvailable() ends"));

    return val;

}

// ----------------------------------------------------------------------------

// CNetMon::NetworkUp1

// ----------------------------------------------------------------------------

void CNetMon::NetworkUp1()

{

    DBG_FILE(_S8("CNetMon::NetworkUp1() begins"));

    // Check if network is already up

    // Compensates for this process startup time

    if ( PacketDataAvailable() )

    {

    	iState = ENetworkUp1;

    	IssueRequest();

    }

    DBG_FILE(_S8("CNetMon::NetworkUp1() ends"));

}

// ----------------------------------------------------------------------------

// CNetMon::CancelTimer

// ----------------------------------------------------------------------------

/*void CNetMon::CancelTimer()

{

    DBG_FILE(_S8("CNetMon::CancelTimer() begins"));

    if ( iStabilityTimer )

    {

	    iStabilityTimer->Cancel();

	    delete iStabilityTimer;

	    iStabilityTimer = NULL;

    }

    DBG_FILE(_S8("CNetMon::CancelTimer() ends"));

}*/

// ----------------------------------------------------------------------------

// CNetMon::CancelGlobalTimer

// ----------------------------------------------------------------------------

void CNetMon::CancelGlobalTimer()

{

    DBG_FILE(_S8("CNetMon::CancelGlobalTimer() begins"));

    if ( iGlobalTimer )

    {

	    iGlobalTimer->Cancel();

	    delete iGlobalTimer;

	    iGlobalTimer = NULL;

    }

    DBG_FILE(_S8("CNetMon::CancelGlobalTimer() ends"));

}

// ----------------------------------------------------------------------------

// CNetMon::NetworkStable

// ----------------------------------------------------------------------------

void CNetMon::NetworkStable()

{

    DBG_FILE(_S8("CNetMon::NetworkStable() begins"));

    // Un-register for events

    iConnectionMonitor.CancelNotifications();

 	iState = ENetworkUp2;

    IssueRequest();

    DBG_FILE(_S8("CNetMon::NetworkStable() ends"));

}

// ----------------------------------------------------------------------------

// CNetMon::NetworkUp2

// ----------------------------------------------------------------------------

TInt CNetMon::NetworkUp2(TAny* aPtr)

{

    DBG_FILE(_S8("CNetMon::NetworkUp2() begins"));

    CNetMon* ptr = (CNetMon*) aPtr;

    if ( ptr->PacketDataAvailable() )

    {

        ptr->NetworkStable();

    }

    //ptr->CancelTimer();       

    DBG_FILE(_S8("CNetMon::NetworkUp2() ends"));

    return KErrNone;

}

// ----------------------------------------------------------------------------

// CNetMon::OtherSyncStatus

// ----------------------------------------------------------------------------

void CNetMon::OtherSyncStatus()

{

    DBG_FILE(_S8("CNetMon::OtherSyncStatus() begins"));

	TInt syncStatus = -1;

	TInt err = iProperty.Get( KPSUidDataSynchronizationInternalKeys, 

	                          KDataSyncStatus, 

	                          syncStatus );

    if ( err != KErrNotFound )  

    {

        if ( syncStatus != EDataSyncNotRunning )

        {

            iProperty.Subscribe(iStatus);

            SetActive();

            DBG_FILE(_S8("CNetMon::OtherSyncStatus() Other sync is in progress. Waiting ..."));

            DBG_FILE(_S8("CNetMon::OtherSyncStatus() ends"));

            return;

        }

    }

    DBG_FILE(_S8("CNetMon::OtherSyncStatus() No other sync is in progress"));

    iState = ESyncOk;

    IssueRequest();

    DBG_FILE(_S8("CNetMon::OtherSyncStatus() ends"));

}

// ----------------------------------------------------------------------------

// CNetMon::InitTimerL

// ----------------------------------------------------------------------------

/*void CNetMon::InitTimerL()

{

    DBG_FILE(_S8("CNetMon::InitTimerL() begins"));

    CancelTimer();

	// Start timer and associate NetworkUp2

	TInt timeout =  KStabilityTimeout * KMicroSecond;        

	iStabilityTimer = CPeriodic::NewL (EPriorityNormal) ;

	iStabilityTimer->Start ( TTimeIntervalMicroSeconds32(timeout), 

	                         TTimeIntervalMicroSeconds32(timeout), 

	                         TCallBack(NetworkUp2, this ) );

    DBG_FILE(_S8("CNetMon::InitTimerL() ends"));	                         	                         

}*/

// ----------------------------------------------------------------------------

// CNetMon::StartSyncL

// ----------------------------------------------------------------------------

void CNetMon::StartSyncL()

{

    DBG_FILE(_S8("CNetMon::StartSyncL() begins"));

    TBool doSync = EFalse;

    // Open sync session

    OpenSyncSessionL();

    doSync = AutoStartPolicyOkL();

    if ( doSync )

    {

    	//Set the Interrupt flag in the CenRep

		UpdateInterruptFlagL(KValidInterrupt);    	

    	// Trigger sync here	    

	    // Register for sync events    

	    iSyncSession.RequestEventL(*this);     // for MSyncMLEventObserver events      

	    iSyncSession.RequestProgressL(*this);  // for MSyncMLProgressObserver events

	    //Error fix for BPSS-7GYDJV

	    CreateSyncJobL();

	    iState = EInitSync;

	    IssueRequest();

    }

    else 

    {

    	iState = EComplete;

	    IssueRequest();

    }

    DBG_FILE(_S8("CNetMon::StartSyncL() ends"));

}

// ----------------------------------------------------------------------------

// CNetMon::CreateSyncJobL

// ----------------------------------------------------------------------------

void CNetMon::CreateSyncJobL()

{

	DBG_FILE(_S8("CNetMon::CreateSyncJobL() begins"));

	CNsmlProfileUtil* profileutil = CNsmlProfileUtil::NewLC();			 	

	RArray<TSmlTaskId> taskIdArray;

	//Get the TaskIds' from the Cenrep

	profileutil->InternalizeTaskIdL(taskIdArray);

	// Create the job

    if(taskIdArray.Count() > 0)

    {

    	DBG_FILE(_S8("CNetMon::CreateSyncJobL() Sync Job Created with Task Id"));

    	iSyncJob.CreateL(iSyncSession, iLastUsedProfileId, taskIdArray );

    }    	

    else

    {

    	DBG_FILE(_S8("CNetMon::CreateSyncJobL() Sync Job Created"));

    	iSyncJob.CreateL(iSyncSession, iLastUsedProfileId);

    }

    taskIdArray.Close();

    CleanupStack::PopAndDestroy(profileutil);

    DBG_FILE(_S8("CNetMon::CreateSyncJobL() ends"));

}

// ----------------------------------------------------------------------------

// CNetMon::OpenSyncSessionL

// ----------------------------------------------------------------------------

void CNetMon::OpenSyncSessionL()

{

	DBG_FILE(_S8("CNetMon: OpenSyncSessionL() Beigns"));

	if (!iSyncSessionOpen)

	{

	    TRAPD(err, iSyncSession.OpenL());

	    if (err != KErrNone)

    	{

	    	DBG_FILE(_S8("CNetMon: RSyncMLSession::OpenL failed "));

	    	User::Leave(err);

    	}

	}

	iSyncSessionOpen = ETrue;

	DBG_FILE(_S8("CNetMon: OpenSyncSessionL() Ends"));

}

// ----------------------------------------------------------------------------

// CNetMon::Complete

// ----------------------------------------------------------------------------

void CNetMon::Complete()

{

    DBG_FILE(_S8("CNetMon::Complete() begins"));

    // Close the server

    CActiveScheduler::Stop();

    DBG_FILE(_S8("CNetMon::Complete() ends"));

}

// ----------------------------------------------------------------------------

// CNetMon::CloseSyncSession

// ----------------------------------------------------------------------------

void CNetMon::CloseSyncSession()

{