/*

* 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:  

*

*/

// INCLUDES

#include <SyncMLTransportProperties.h>

#include <flogger.h>

#include <eikenv.h>

#include <bautils.h>  // BaflUtils

#include <AiwGenericParam.hrh>  // for application ids

#include <collate.h>   // for TCollationMethod

#include <featmgr.h>   // FeatureManager

#include <ApUtils.h>   // CApUtils

#include <avkon.rsg>

#include <hlplch.h>    // HlpLauncher

#include <MuiuMsvUiServiceUtilities.h> // for MsvUiServiceUtilities

#include "AspUtil.h"

#include "AspDialogUtil.h"

#include "AspResHandler.h"

#include "AspDebug.h"

#include <AspSyncUtil.rsg>

#include <SyncMLErr.h>  // sync error codes

//#ifdef __SAP_POLICY_MANAGEMENT

#include <SettingEnforcementInfo.h> // VSettingEnforcementInfo

//#endif

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

 * class TAspParam

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

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

// TAspParam::TAspParam

//

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

//

TAspParam::TAspParam(TInt aApplicationId)

 : iApplicationId(aApplicationId), iProfileId(KErrNotFound), iMode(KErrNotFound),

   iId(KErrNotFound), iReturnValue(KErrNotFound), iDataProviderId(KErrNotFound),

   iSyncTaskId(KErrNotFound), iProfile(NULL), 

   iSyncTask(NULL), iSyncFilter(NULL), iSyncSession(NULL),

   iProfileList(NULL), iContentList(NULL), iSchedule(NULL)

	 {

	 }

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

// TAspParam::TAspParam

//

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

//

TAspParam::TAspParam(TInt aApplicationId, RSyncMLSession* aSyncSession)

 : iApplicationId(aApplicationId), iProfileId(KErrNotFound), iMode(KErrNotFound),

   iId(KErrNotFound), iReturnValue(KErrNotFound), iDataProviderId(KErrNotFound),

   iSyncTaskId(KErrNotFound), iProfile(NULL),

   iSyncTask(NULL), iSyncFilter(NULL), iSyncSession(aSyncSession),

   iProfileList(NULL), iContentList(NULL), iSchedule(NULL)

  	 {

	 }

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

 * class TAspUtil

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

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

// TUtil::Panic

//

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

//

void TUtil::Panic(TInt aReason)

    {

	_LIT(KPanicCategory,"AspSyncUtil");

	User::Panic(KPanicCategory, aReason); 

    }

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

// TUtil::StrCopy

//

// String copy with lenght check.

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

//

void TUtil::StrCopy(TDes8& aTarget, const TDesC& aSource)

    {

	TInt len = aTarget.MaxLength();

    if(len < aSource.Length()) 

	    {

		aTarget.Copy(aSource.Left(len));

		return;

	    }

	aTarget.Copy(aSource);

    }

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

// TUtil::StrCopy

//

// String copy with lenght check.

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

//

void TUtil::StrCopy(TDes& aTarget, const TDesC8& aSource)

    {

	TInt len = aTarget.MaxLength();

    if(len < aSource.Length()) 

	    {

		aTarget.Copy(aSource.Left(len));

		return;

	    }

	aTarget.Copy(aSource);

    }

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

// TUtil::StrCopy

//

// String copy with lenght check.

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

//

void TUtil::StrCopy(TDes& aTarget, const TDesC& aSource)

    {

	TInt len = aTarget.MaxLength();

    if(len < aSource.Length()) 

	    {

		aTarget.Copy(aSource.Left(len));

		return;

	    }

	aTarget.Copy(aSource);

    }

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

//TUtil::StrConversion

//

//Convert TBuf to HBuf

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

//

HBufC* TUtil::StrConversion(const TDesC& aDefaultText)

{

	return aDefaultText.AllocLC();

    }

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

// TUtil::StrAppend

//

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

//

void TUtil::StrAppend(TDes& aTarget, const TDesC& aSource)

{

    if (aSource.Length() == 0)

    	{

    	return;

    	}

	TInt free = aTarget.MaxLength() - aTarget.Length();

	if (aSource.Length() < free)

		{

		aTarget.Append(aSource);

		}

}

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

// TUtil::StrInsert

//

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

//

void TUtil::StrInsert(TDes& aTarget, const TDesC& aSource)

{

	TInt free = aTarget.MaxLength() - aTarget.Length();

	if (aSource.Length() < free)

		{

		aTarget.Insert(0, aSource);

		}

}

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

// TUtil::StrToInt

//

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

//

TInt TUtil::StrToInt(const TDesC& aText, TInt& aNum)

	{

    TLex lex(aText);

    TInt err=lex.Val(aNum); 

	return err;

	}

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

// TUtil::IsEmpty

//

// Function returns ETrue if string only contains white space or has no characters.

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

//

TBool TUtil::IsEmpty(const TDesC& aText)

	{

	TInt len=aText.Length();

	for (TInt i=0; i<len; i++)

		{

		TChar c=aText[i];

		if (!c.IsSpace())

			{

			return EFalse;

			}

		}

	return ETrue;

	}

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

// TUtil::Fill

//

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

//

void TUtil::Fill(TDes& aTarget, const TDesC& aOneCharStr, TInt aLength)

	{

	TInt len = aTarget.MaxLength();

    if(len > aLength)

    	{

    	TBuf<KBufSize16> buf(aOneCharStr);

	    aTarget.Fill(buf[0], aLength);

    	}

	}

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

// TUtil::AddResFileL

//

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

//

TInt TUtil::AddResFileL(const TDesC& aFile)

	{

	CEikonEnv* env = CEikonEnv::Static();

	TFileName fileName(aFile);

	BaflUtils::NearestLanguageFile(env->FsSession(), fileName);

    return env->AddResourceFileL(fileName);

	}

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

// TUtil::IsValidAppId

//

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

//

TBool TUtil::IsValidAppId(TInt aApplicationId)

	{

	TInt id = aApplicationId;

	if (id == EApplicationIdSync || id == EApplicationIdContact || 

	    id == EApplicationIdCalendar || id == EApplicationIdEmail ||

	    id == EApplicationIdNote || id == EApplicationIdMms)

		{

		return ETrue;

		}

	return EFalse;

	}

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

// TUtil::IsValidSID

//

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

//

TBool TUtil::IsValidSID(TInt aSid)

	{

	TInt id = aSid;

	if (id == KUidAppSync.iUid || id == KUidAppPhonebook.iUid || 

	    id == KUidAppCalendar.iUid || id == KUidAppMessages.iUid ||

	    id == KUidAppNotepad.iUid || id == KUidAppTest.iUid || 

	    id == KUidAppMailEditor.iUid)

		{

		return ETrue;

		}

	return EFalse;

	}

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

// TUtil::ProviderIdFromAppId

//

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

//

TInt TUtil::ProviderIdFromAppId(TInt aApplicationId)

	{

	TInt id=KErrNotFound;

	switch (aApplicationId)

		{

		case EApplicationIdContact:

			id = KUidNSmlAdapterContact.iUid;

			break;

		case EApplicationIdCalendar:

			id = KUidNSmlAdapterCalendar.iUid;

			break;

		case EApplicationIdEmail:

     		id = KUidNSmlAdapterEMail.iUid;

			break;

		case EApplicationIdNote:

			id = KUidNSmlAdapterNote.iUid;

			break;

		default:

            id = KErrNotFound;

			break;

		}

	return id;

	}

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

// TUtil::AppIdFromProviderId

//

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

//

TInt TUtil::AppIdFromProviderId(TInt aAdapterId)

	{

	TInt id=KErrNotFound;

	if (aAdapterId == KUidNSmlAdapterContact.iUid)

		{

		id = EApplicationIdContact;

		}

	if (aAdapterId == KUidNSmlAdapterCalendar.iUid)

		{

		id = EApplicationIdCalendar;

		}

	if (aAdapterId == KUidNSmlAdapterEMail.iUid)

		{

		id = EApplicationIdEmail;

		}

	if (aAdapterId == KUidNSmlAdapterNote.iUid)

		{

		id = EApplicationIdNote;

		}

	return id;

	}

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

// TUtil::IsToDay

//

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

//

TBool TUtil::IsToday(TTime aTime)

	{

	TTime now;

	now.HomeTime();

	TInt day1 = now.DayNoInYear();

	TInt day2 = aTime.DayNoInYear();

	TDateTime date1 = now.DateTime();

	TDateTime date2 = aTime.DateTime();

	TTimeIntervalDays daysBetween = now.DaysFrom(aTime);

	if (day1 != day2 || date1.Year() != date2.Year())

		{

		return EFalse;

		}

	if (daysBetween.Int() > 0)

		{

		return EFalse;

		}

	return ETrue; 

	}

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

// TUtil::SyncTimeLC

//

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

//

HBufC* TUtil::SyncTimeLC(TTime aLastSync)

	{

	TTime homeTime = ConvertUniversalToHomeTime(aLastSync);

	HBufC* hBuf = HBufC::NewLC(KBufSize255);

	TPtr ptr = hBuf->Des();

	if (IsToday(homeTime))

		{

		TBuf<KBufSize> timeFormat;

		CAspResHandler::ReadL(timeFormat, R_QTN_TIME_USUAL_WITH_ZERO);

		homeTime.FormatL(ptr, timeFormat);

		}

	else

		{

		TBuf<KBufSize> dateFormat;

		CAspResHandler::ReadL(dateFormat, R_QTN_DATE_USUAL_WITH_ZERO);

		homeTime.FormatL(ptr, dateFormat);

		}

	return hBuf;

	}

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

// TUtil::ConvertUniversalToHomeTime

//

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

//

TTime TUtil::ConvertUniversalToHomeTime(const TTime& aUniversalTime)

    {

    TTime time(aUniversalTime);   // time stores UTC time.

    TLocale locale;

    TTimeIntervalSeconds universalTimeOffset(locale.UniversalTimeOffset());

    // Add locale's universal time offset to universal time.

    time += universalTimeOffset;    // time stores Local Time.

    // If home daylight saving in effect, add one hour offset.

    if (locale.QueryHomeHasDaylightSavingOn())

        {

        TTimeIntervalHours daylightSaving(1);

        time += daylightSaving;

        }

    return time;

    }

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

// TUtil::GetDateTextL

//

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

//

void TUtil::GetDateTextL(TDes& aText, TTime aDateTime)

	{

	TTime homeTime = ConvertUniversalToHomeTime(aDateTime);

	HBufC* hBuf = CAspResHandler::ReadLC(R_QTN_DATE_USUAL_WITH_ZERO);

    homeTime.FormatL(aText, *hBuf);

    CleanupStack::PopAndDestroy(hBuf);

	}

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

// TUtil::GetTimeTextL

//

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

//

void TUtil::GetTimeTextL(TDes& aText, TTime aDateTime)

	{

	TTime homeTime = ConvertUniversalToHomeTime(aDateTime);

	HBufC* hBuf = CAspResHandler::ReadLC(R_QTN_TIME_USUAL_WITH_ZERO);

    homeTime.FormatL(aText, *hBuf);

    CleanupStack::PopAndDestroy(hBuf);

	}

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

// TUtil::GetDateTimeTextL

//

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

//

void TUtil::GetDateTimeTextL(TDes& aText, TTime aDateTime)

	{

	TDateTime dt = aDateTime.DateTime();

	aText.Format(_L("%02d.%02d.%04d %02d:%02d:%02d"), dt.Day()+1, dt.Month()+1, dt.Year(),  dt.Hour(), dt.Minute(), dt.Second());

	}

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

// TUtil::LaunchHelpAppL

//

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

//

void TUtil::LaunchHelpAppL()

	{

	if (!FeatureManager::FeatureSupported(KFeatureIdHelp))

		{

		return;

		}

	CEikonEnv* eikEnv = CEikonEnv::Static();

	HlpLauncher::LaunchHelpApplicationL(eikEnv->WsSession(), eikEnv->EikAppUi()->AppHelpContextL());

	}

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

// TUtil::LaunchHelpAppL

//

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