/*

* Copyright (c) 2002-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:  

*

*/

// INCLUDE FILES

#include "AspAutoSyncHandler.h"

#include "AspUtil.h"

#include "AspDialogUtil.h"

#include "AspDebug.h"

#include <schinfo.h> // TScheduleEntryInfo2

#include <s32mem.h>  // RDesWriteStream

#include <s32file.h> // RFileReadStream

//#include <centralrepository.h>  // CRepository

#include <rconnmon.h>

_LIT(KPeakTaskData, "aspschedulehandler peak task");

_LIT(KOffPeakTaskData, "aspschedulehandler off-peak task");

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

/*******************************************************************************

 * class CAspAutoSyncHandler

 *******************************************************************************/

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

// CAspAutoSyncHandler::NewL

//

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

//

CAspAutoSyncHandler* CAspAutoSyncHandler::NewL()

    {

    CAspAutoSyncHandler* self = new (ELeave) CAspAutoSyncHandler();

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return(self);

    }

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

// CAspAutoSyncHandler::CAspAutoSyncHandler

// 

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

//

CAspAutoSyncHandler::CAspAutoSyncHandler()

	{

	iSyncError = KErrNone;

	iSyncSessionOpen = EFalse;

	iSyncRunning = EFalse;

    }

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

// CAspAutoSyncHandler::ConstructL

//

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

//

void CAspAutoSyncHandler::ConstructL()

    {

    iWait = new (ELeave) CActiveSchedulerWait();

    iSchedule = CAspSchedule::NewL();

    } 

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

// Destructor

//

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

//

CAspAutoSyncHandler::~CAspAutoSyncHandler()

    {

    if (iWait && iWait->IsStarted())

        {

        iWait->AsyncStop();

        }

    delete iWait;

    delete iSchedule;

    CloseSyncSession();

    }

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

// CAspAutoSyncHandler::OnSyncMLSessionEvent (from MSyncMLEventObserver)

//

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

//

void CAspAutoSyncHandler::OnSyncMLSessionEvent(TEvent aEvent, TInt /*aIdentifier*/,

                                           TInt aError, TInt /*aAdditionalData*/)

	{

	FLOG( _L("CAspAutoSyncHandler::OnSyncMLSessionEvent START") );

	if (aEvent == EJobStart)

		{

        FLOG( _L("EJobStart") );

		}

	if (aEvent == EJobStop)

		{

    	if (aError != KErrNone)

			{

			iSyncError = aError;

    		}

        FLOG( _L("EJobStop") );

    	iWait->AsyncStop();

		}

	if (aEvent == EJobStartFailed || aEvent == EJobRejected || aEvent == EServerTerminated)

		{

		FLOG( _L("EJobStartFailed or EJobRejected or EServerTerminated") );

		iWait->AsyncStop();

		}

	FLOG( _L("CAspAutoSyncHandler::OnSyncMLSessionEvent END") );

    }

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

// CAspAutoSyncHandler::OnSyncMLSyncError (from MSyncMLProgressObserver)

//

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

//

void CAspAutoSyncHandler::OnSyncMLSyncError(TErrorLevel aErrorLevel,

                                                TInt aError, TInt /*aTaskId*/,

                                                TInt /*aInfo1*/, TInt /*aInfo2*/)

	{

	FLOG( _L("CAspAutoSyncHandler::OnSyncMLSyncError START") );

	if (aErrorLevel == ESmlFatalError)

		{

		iSyncError = aError;

		iWait->AsyncStop();

		}

	FLOG( _L("CAspAutoSyncHandler::OnSyncMLSyncError END") );

	}

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

// CAspAutoSyncHandler::OnSyncMLSyncProgress (from MSyncMLProgressObserver)

//

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

//

void CAspAutoSyncHandler::OnSyncMLSyncProgress(TStatus /*aStatus*/,

                                                   TInt /*aInfo1*/, TInt /*aInfo2*/)

	{

	// not needed in scheduled sync

	}

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

// CAspAutoSyncHandler::OnSyncMLDataSyncModifications (from MSyncMLProgressObserver)

//

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

//

void CAspAutoSyncHandler::OnSyncMLDataSyncModifications(TInt /*aTaskId*/, 

	         const TSyncMLDataSyncModifications& /*aClientModifications*/,

	         const TSyncMLDataSyncModifications& /*aServerModifications*/)

	{

	// not needed in scheduled sync

	}

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

// CAspAutoSyncHandler::OpenSyncSessionL

// 

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

//

void CAspAutoSyncHandler::OpenSyncSessionL()

	{

	if (!iSyncSessionOpen)

		{

        TRAPD(err, iSyncSession.OpenL());

        if (err != KErrNone)

        	{

        	FLOG( _L("### CAspAutoSyncHandler: RSyncMLSession::OpenL failed (%d) ###"), err );

        	User::Leave(err);

        	}

		iSyncSessionOpen = ETrue;

		}

    }

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

// CloseSyncSession

// 

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

//

void CAspAutoSyncHandler::CloseSyncSession()

	{

	if (iSyncSessionOpen)

		{

		iSyncJob.Close(); // this can be done when job has not been opened

		iSyncSession.Close();

		iSyncSessionOpen = EFalse;

		}

    }

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

// CAspAutoSyncHandler::CheckMandatoryData

// 

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

//

TInt CAspAutoSyncHandler::CheckMandatoryDataL(TInt aProfileId)

	{

    TAspParam param(EApplicationIdSync, &iSyncSession);

    CAspProfile* profile = CAspProfile::NewLC(param);

    profile->OpenL(aProfileId, CAspProfile::EOpenRead, CAspProfile::EAllProperties);

	param.iProfile = profile;

	param.iMode = CAspContentList::EInitAll;

	CAspContentList* list = CAspContentList::NewLC(param);

   	//TInt contentCount = 0;

	TInt mandatoryConnectionData = CAspProfile::CheckMandatoryConnData(profile);

	//TInt mandatoryContentData    = list->CheckMandatoryDataL(contentCount);

	TInt mandatoryBearerType = EMandatoryOk;

	if (profile->BearerType() != EAspBearerInternet)

		{

		mandatoryBearerType = EMandatoryIncorrectBearerType;

		}

	TInt mandatoryAccessPoint = EMandatoryOk;

	/*if (profile->AccessPointL() == CAspAccessPointHandler::KAskAlways)

		{

		mandatoryAccessPoint = EMandatoryIncorrectAccessPoint;

		}*/

	CleanupStack::PopAndDestroy(list);

	CleanupStack::PopAndDestroy(profile);

	if (mandatoryBearerType != EMandatoryOk)

		{

		return mandatoryBearerType;

		}

	if (mandatoryAccessPoint != EMandatoryOk)

		{

		return mandatoryAccessPoint;

		}

	if (mandatoryConnectionData != EMandatoryOk)

		{

		return mandatoryConnectionData;

		}

	return EMandatoryOk;//mandatoryContentData;

    }

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

// CAspAutoSyncHandler::SynchronizeL

// 

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

//

void CAspAutoSyncHandler::SynchronizeL(RFile& aTaskFile)

	{

	FLOG( _L("CAspAutoSyncHandler::SynchronizeL START") );

	CFileStore*         store;

    RStoreReadStream    instream;

    // Get tasks from scheduler's store

    store = CDirectFileStore::FromLC(aTaskFile);

    instream.OpenLC(*store,store->Root());

    TInt count = instream.ReadInt32L();

	CScheduledTask* task = CScheduledTask::NewLC(instream);

    HBufC* taskData = const_cast<HBufC*>(&(task->Data()));

    TPtr ptr = taskData->Des();

    TBool doCleanUp = ETrue;

	if (ptr.Compare(KPeakTaskData) == 0)

		{

	 FLOG( _L("Peak Sync Scheduled") );

		TInt interval = iSchedule->SyncPeakSchedule();

		if (iSchedule->IntervalType(interval) == EHourly

					&& interval != CAspSchedule::EIntervalManual)

			{

			if (iSchedule->IsValidPeakScheduleL() != 0)

				{

				//postpone peak schedule until next peak start

				iSchedule->UpdatePeakScheduleL();

				CleanupStack::PopAndDestroy(task);

    			CleanupStack::PopAndDestroy( &instream ); 

				CleanupStack::PopAndDestroy( store ); 

				doCleanUp = EFalse;

				return;

				}

			else

				{

				//schedule next sync

				if(!iSchedule->IsValidNextPeakScheduleL())

					{

					iSchedule->UpdatePeakScheduleL();

					}

				else 

					{

					CAspSyncSchedule* syncSchedule = CAspSyncSchedule::NewLC();

					syncSchedule->EditPeakScheduleL(iSchedule);

					CleanupStack::PopAndDestroy(syncSchedule);

					}

				}

			}

		else

			{

			//schedule next sync

			CAspSyncSchedule* syncSchedule = CAspSyncSchedule::NewLC();

			syncSchedule->EditPeakScheduleL(iSchedule);

			CleanupStack::PopAndDestroy(syncSchedule);

			}

		}

	if (ptr.Compare(KOffPeakTaskData) == 0)

		{

		FLOG( _L("Off-Peak Sync Scheduled") );

		TInt interval = iSchedule->SyncOffPeakSchedule();

		if (iSchedule->IntervalType(interval) == EHourly)

			{

			if (iSchedule->IsValidOffPeakScheduleL() != 0)

				{

				//postpone off-schedule until next off-peak start

				iSchedule->UpdateOffPeakScheduleL();

				CleanupStack::PopAndDestroy(task);

				CleanupStack::PopAndDestroy( &instream ); 

				CleanupStack::PopAndDestroy( store ); 

				doCleanUp = EFalse;

				return;

				}

			else

				{

				//schedule next sync

				if(!iSchedule->IsValidNextOffPeakScheduleL())

					{

					iSchedule->UpdateOffPeakScheduleL();

					}

				else

					{

					CAspSyncSchedule* syncSchedule = CAspSyncSchedule::NewLC();

					syncSchedule->EditOffPeakScheduleL(iSchedule);

					CleanupStack::PopAndDestroy(syncSchedule);

					}

				}

			}

		}

	if(doCleanUp)	

		{

			CleanupStack::PopAndDestroy(task);

			CleanupStack::PopAndDestroy( &instream ); 

			CleanupStack::PopAndDestroy( store ); 

			doCleanUp = EFalse;

		}

	iSchedule->SetError(KErrNone);

	iSchedule->SaveL();

	TRAPD (err, DoSynchronizeL());

	User::LeaveIfError(err);

}

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

// CAspAutoSyncHandler::DoSynchronizeL

// 

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

//

void CAspAutoSyncHandler::DoSynchronizeL()

{

	OpenSyncSessionL();

	if (CAspProfile::OtherSyncRunning(&iSyncSession))

		{

		FLOG( _L("### other sync running ###") );

		TInt currentJobId = CAspProfile::CurrentJob(&iSyncSession);

		if (currentJobId != KErrNotFound)

			{

			iSyncJob.OpenL(iSyncSession, currentJobId);

			if (iSchedule->ProfileId() != iSyncJob.Profile())

				{

				FLOG( _L("CAspAutoSyncHandler::SynchronizeL Set Error") );

				iSchedule->SetError(EOtherSyncRunning);

				iSchedule->SaveL();

				}

			iSyncJob.Close();

			}

		FLOG( _L("CAspAutoSyncHandler::SynchronizeL END") );

		return;

		}

    TInt profileId = iSchedule->AutoSyncProfileId();

	iSchedule->UpdateProfileSettingsL();

	iSchedule->SaveL();

#ifdef _DEBUG

	iSchedule->LogScheduleL();

#endif

	if (!iSchedule->CanSynchronizeL())

		{

		FLOG( _L("### incorrect auto sync settings ###") );

		FLOG( _L("CAspAutoSyncHandler::SynchronizeL END") );

	    //iSchedule->SetError(EIncorrectSchedule);

		//iSchedule->SaveL();

		return;

		}

#if 0 //roaming check not supported		

	if (!iSchedule->RoamingAllowed())

		{

		if (IsRoaming())

			{

		    FLOG( _L("### cannot sync when roaming ###") );

		    FLOG( _L("CAspAutoSyncHandler::SynchronizeL END") );

		    return;

			}

		}

#endif

	if (CheckMandatoryDataL(profileId) != EMandatoryOk)

		{

		FLOG( _L("### incorrect sync profile settings ###") );

		FLOG( _L("CAspAutoSyncHandler::SynchronizeL END") );

		//iSchedule->SetError(EIncorrectProfile);

		//iSchedule->SaveL();

		return;

		}

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

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

    iSyncJob.CreateL(iSyncSession, profileId);  // start sync

    iSyncRunning = ETrue;

    iWait->Start();  // stop here until sync has completed

   	iSyncRunning = EFalse;

	iSchedule->UpdateServerIdL();

   	if (iSyncError != KErrNone)

		{

		iSchedule->SetError(iSyncError);

		iSchedule->SaveL();

     	FLOG(_L("### auto sync failed (%d) ###"), iSyncError);

		}

    FLOG( _L("CAspAutoSyncHandler::SynchronizeL END") );

}

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

// CAspAutoSyncHandler::IsRoamingL

// 

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

//

TBool CAspAutoSyncHandler::IsRoamingL()

	{

	RConnectionMonitor conMon;

	conMon.ConnectL();

    TRequestStatus status;

    TInt registrationStatus(0);

    //check network status

    conMon.GetIntAttribute(EBearerIdGSM, 0, KNetworkRegistration, 

                            registrationStatus, status);

    User::WaitForRequest(status);

    conMon.Close();

    if (registrationStatus == ENetworkRegistrationRoaming)

    	{

    	return ETrue;	

    	}

    return EFalse;

    }

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

// CAspAutoSyncHandler::IsRoaming

// 

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

//