/*

* 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 "AspSchedule.h"

#include "AspUtil.h"

#include "AspDialogUtil.h"

#include "AspDebug.h"

#include "AspProfile.h"

#include "AspLogDialog.h"

#include "AspAutoSyncHandler.h"

#include "schinfo.h" // TScheduleEntryInfo2

#include <s32mem.h>  // RDesWriteStream

#include <s32file.h> // RFileReadStream

#include <bautils.h> // BaflUtils

#include <centralrepository.h>  // CRepository

#include <rconnmon.h>

#include <SyncMLClientDS.h>

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

 * class CAspSchedule

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

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

// CAspSchedule::NewL

//

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

//

CAspSchedule* CAspSchedule::NewL()

    {

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

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return(self);

    }

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

// CAspSchedule::NewLC

//

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

//

CAspSchedule* CAspSchedule::NewLC()

    {

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

    CleanupStack::PushL(self);

    self->ConstructL();

    return(self);

    }

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

// CAspSchedule::CAspSchedule

// 

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

//

CAspSchedule::CAspSchedule()

	{

	iSettingChanged = EFalse;

	iSyncSessionOpen = EFalse;

    }

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

// CAspSchedule::ConstructL

//

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

//

void CAspSchedule::ConstructL()

    {

    InternalizeL();

	if(iAutoSyncProfileId == KErrNotFound)

		{

		CreateAutoSyncProfileL();

		}

    } 

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

// Destructor

//

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

//

CAspSchedule::~CAspSchedule()

    {

    iList.Close();

	CloseSyncSession();

    }

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

// InitializeL

//

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

//

void CAspSchedule::InitializeL()

    {

    FLOG( _L("CAspSchedule::InitializeL START") );

    iError          = KErrNone;

    iProfileId      = KErrNotFound;

    iRoamingAllowed = EFalse;

	iDailySyncEnabled = EFalse;

	iPeakSyncEnabled = EFalse;

	iOffPeakSyncEnabled = EFalse;

	iContentFlags = 0xFF;

	iSyncFrequency          = EIntervalManual;

	iSyncPeakSchedule       = EIntervalManual;

    iSyncOffPeakSchedule    = EIntervalManual;

    iPeakScheduleHandle = KErrNotFound;

	iOffPeakScheduleHandle = KErrNotFound;

	iStartPeakTimeHr		 = KStartPeakHour;

	iStartPeakTimeMin		 = KStartPeakMin;

	iEndPeakTimeHr         = KEndPeakHour;

	iEndPeakTimeMin         = KEndPeakMin;

	iAutoSyncProfileId = KErrNotFound;

	iAutoSyncScheduleTimeHr = KDefaultStartHour;

	iAutoSyncScheduleTimeMin = 0;

	SetWeekdayEnabled(EMonday,    ETrue);

   	SetWeekdayEnabled(ETuesday,   ETrue);

   	SetWeekdayEnabled(EWednesday, ETrue);

   	SetWeekdayEnabled(EThursday,  ETrue);

   	SetWeekdayEnabled(EFriday,    ETrue);

   	SetWeekdayEnabled(ESaturday,  EFalse);

   	SetWeekdayEnabled(ESunday,    EFalse);

	InitializeContentsL();

	FLOG( _L("CAspSchedule::InitializeL END") );

    }

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

// InitializeContentsL

//

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

//

void CAspSchedule::InitializeContentsL()

	{

	OpenSyncSessionL();

	TAspParam param(EApplicationIdSync, &iSyncSession);

	param.iMode = CAspContentList::EInitDataProviders;

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

	TInt providerCount = asContentList->ProviderCount();

	for (TInt index = 0; index < providerCount; index++)

		{

		TAspProviderItem& provider = asContentList->ProviderItem(index);

		if (provider.iDataProviderId == KUidNSmlAdapterEMail.iUid)

			{

			if (MailboxExistL())

				{

				SetContentEnabled(index, ETrue);

				}

			else

				{

				SetContentEnabled(index, EFalse);

				}

			}

		else

			{

			SetContentEnabled(index, ETrue);

			}

		}

	CleanupStack::PopAndDestroy(asContentList);

	}

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

// CAspSchedule::DoInternalizeL

//

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

//

void CAspSchedule::DoInternalizeL()

	{

	const TInt KMaxLength = 1024;

    HBufC8*  hBuf = HBufC8::NewLC(KMaxLength);

    TPtr8 ptr = hBuf->Des();

    ReadRepositoryL(ERepositoryKeyBin, ptr);

    RDesReadStream stream(ptr);

    stream.PushL();

    InternalizeL(stream);

    stream.Pop();

    stream.Close();

    CleanupStack::PopAndDestroy(hBuf);

	}

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

// CAspSchedule::InternalizeL

//

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

//

void CAspSchedule::InternalizeL()

	{

	FLOG( _L("CAspSchedule::InternalizeL START") );

	TRAPD(err, DoInternalizeL());

	if (err == KErrNoMemory || err == KErrLocked || err == KErrAlreadyExists)

		{

		FLOG( _L("CAspSchedule::InternalizeL Error 1:  %d"),err );

		User::Leave(err);

		}

	else if (err != KErrNone)

		{

		FLOG( _L("CAspSchedule::InternalizeL Error 2:  %d"),err );

		ResetRepositoryL();  // settings corrupted

	    InitializeL();

		}

	}

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

// CAspSchedule::InternalizeL

//

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

//

void CAspSchedule::InternalizeL(RReadStream& aStream)

	{

	const TInt KAutoSyncSettingCount = 20;

    iList.Reset();

    // total setting count

	TInt32 count = 0;

	TRAPD(err, count = aStream.ReadInt32L());

	if (err != KErrNone && err != KErrEof)

		{

		User::Leave(err);

		}

	if (count != KAutoSyncSettingCount)

		{

		InitializeL(); // settings not found - use defaults

		SaveL();

		return;

		}

    iError                 = aStream.ReadInt32L();

    iProfileId             = aStream.ReadInt32L();

    iWeekdayFlags          = aStream.ReadInt32L();

    TInt roamingAllowed    = aStream.ReadInt32L();

	iPeakScheduleHandle = aStream.ReadInt32L();

	iOffPeakScheduleHandle = aStream.ReadInt32L();

	iContentFlags           = aStream.ReadInt32L();

	iSyncPeakSchedule       = aStream.ReadInt32L();

    iSyncOffPeakSchedule    = aStream.ReadInt32L();

	iStartPeakTimeHr		= aStream.ReadInt32L();

	iStartPeakTimeMin		= aStream.ReadInt32L();

	iEndPeakTimeHr          = aStream.ReadInt32L();

	iEndPeakTimeMin         = aStream.ReadInt32L();

	iSyncFrequency          = aStream.ReadInt32L();

	iDailySyncEnabled 			= aStream.ReadInt32L();

	iPeakSyncEnabled        = aStream.ReadInt32L();

	iOffPeakSyncEnabled		= aStream.ReadInt32L();

	iAutoSyncProfileId		= aStream.ReadInt32L();

	iAutoSyncScheduleTimeHr = aStream.ReadInt32L();

	iAutoSyncScheduleTimeMin = aStream.ReadInt32L();

#ifdef _DEBUG

    LogSettings();

#endif

    iRoamingAllowed = EFalse;

    if (roamingAllowed)

    	{

    	iRoamingAllowed = ETrue;

    	}

	CheckEmailSelectionL();

    }   

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

// CAspSchedule::CheckEmailSelectionL()

//

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

//

void CAspSchedule::CheckEmailSelectionL()

	{

	TRAPD(err, OpenSyncSessionL());

	if (err != KErrNone)

		{

		/*OpenSynSessionL() may leave when system time is changed so that peak and off-peak syncs are

		scheduled simulataneously.In that case also next sync time has to be updated. So a leave here should be

		trapped and return to the time update function.	

		*/

		FLOG( _L("Session cannot be opened now : return") );

		return;

		}

	TAspParam param(EApplicationIdSync, &iSyncSession);

	param.iMode = CAspContentList::EInitDataProviders;

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

	TInt providerCount = asContentList->ProviderCount();

	TInt emailIndex = asContentList->FindProviderIndex(KUidNSmlAdapterEMail.iUid);

	if (!MailboxExistL())

		{

		SetContentEnabled(emailIndex, EFalse);

		}

	else if (!IsAutoSyncEnabled())

		{

		SetContentEnabled(emailIndex, ETrue);

		}

	if (iProfileId != KErrNotFound

		 					&& !ProtocolL())

		{

		SetContentEnabled(emailIndex, EFalse);

		}

	CleanupStack::PopAndDestroy(asContentList);

	}

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

// CAspSchedule::ExternalizeL

//

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

//

void CAspSchedule::ExternalizeL()

	{

	const TInt KMaxLength = 1024;

    HBufC8*  hBuf = HBufC8::NewLC(KMaxLength);

    TPtr8 ptr = hBuf->Des();

    RDesWriteStream stream(ptr);

    stream.PushL();

    ExternalizeL(stream);

    stream.CommitL();

    stream.Pop();

    stream.Close();

    TRAPD (err,WriteRepositoryL(ERepositoryKeyBin, ptr));

	User::LeaveIfError(err);

    CleanupStack::PopAndDestroy(hBuf);

	}

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

// CAspSchedule::ExternalizeL

//

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

//

void CAspSchedule::ExternalizeL(RWriteStream& aStream)

	{

	const TInt KAutoSyncSettingCount = 20;

    TInt roamingAllowed = 0;

    if (iRoamingAllowed)

    	{

    	roamingAllowed = 1;

    	}

    aStream.WriteInt32L(KAutoSyncSettingCount);

	aStream.WriteInt32L(iError);

    aStream.WriteInt32L(iProfileId);

    aStream.WriteInt32L(iWeekdayFlags);

    aStream.WriteInt32L(roamingAllowed);

	aStream.WriteInt32L(iPeakScheduleHandle);

	aStream.WriteInt32L(iOffPeakScheduleHandle);

    aStream.WriteInt32L(iContentFlags);

	aStream.WriteInt32L(iSyncPeakSchedule);

	aStream.WriteInt32L(iSyncOffPeakSchedule);

	aStream.WriteInt32L(iStartPeakTimeHr);

	aStream.WriteInt32L(iStartPeakTimeMin);

	aStream.WriteInt32L(iEndPeakTimeHr);

   	aStream.WriteInt32L(iEndPeakTimeMin);

	aStream.WriteInt32L(iSyncFrequency);

	aStream.WriteInt32L(iDailySyncEnabled);

	aStream.WriteInt32L(iPeakSyncEnabled);

	aStream.WriteInt32L(iOffPeakSyncEnabled);

	aStream.WriteInt32L(iAutoSyncProfileId);

    aStream.WriteInt32L(iAutoSyncScheduleTimeHr);

	aStream.WriteInt32L(iAutoSyncScheduleTimeMin);

#ifdef _DEBUG

	LogSettings();

#endif

	}

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

// CAspSchedule::WriteRepositoryL

//

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

//

void CAspSchedule::WriteRepositoryL(TInt aKey, const TDesC8& aValue)

	{

	const TUid KRepositoryId = KCRUidNSmlDSApp; // 0x101F9A1D

    CRepository* rep = CRepository::NewLC(KRepositoryId);

    TInt err = rep->Set(aKey, aValue);

    User::LeaveIfError(err);

    CleanupStack::PopAndDestroy(rep);

	}

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

// CAspSchedule::ReadRepositoryL

//

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

//

void CAspSchedule::ReadRepositoryL(TInt aKey, TDes8& aValue)

	{

	const TUid KRepositoryId = KCRUidNSmlDSApp;

    CRepository* rep = CRepository::NewLC(KRepositoryId);

    TInt err = rep->Get(aKey, aValue);

    User::LeaveIfError(err);

    CleanupStack::PopAndDestroy(rep);

	}

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

// CAspSchedule::ResetRepositoryL

//

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

//

void CAspSchedule::ResetRepositoryL()

	{

	const TUid KRepositoryId = KCRUidNSmlDSApp;

    CRepository* rep = CRepository::NewLC(KRepositoryId);

    TInt err = rep->Reset();

    User::LeaveIfError(err);

    CleanupStack::PopAndDestroy(rep);

	}

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

// CAspSchedule::SaveL

//

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

//

void CAspSchedule::SaveL()

	{

	ExternalizeL();

	}

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

// CAspSchedule::PeakScheduleHandle

//

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

//

TInt CAspSchedule::PeakScheduleHandle()

	{

	return iPeakScheduleHandle;

	}

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

// CAspSchedule::SetPeakScheduleHandle

//

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

//

void CAspSchedule::SetPeakScheduleHandle(TInt aScheduleHandle)

	{

	iPeakScheduleHandle = aScheduleHandle;

	}