/*

* 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 <NsmlOperatorDataCRKeys.h> // KCRUidOperatorDatasyncInternalKeys

#include "AspUtil.h"

#include "AspDialogUtil.h"

#include "AspResHandler.h"

#include "AspDebug.h"

#include <AspSyncUtil.rsg>

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

#include <cmapplicationsettingsui.h>

//#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::ProviderIdFromAppId

//

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

//

TInt TUtil::ProviderIdFromAppId(TInt aApplicationId, TBool aOperatorProfile)

    {

    TInt id=KErrNotFound;

    if (aOperatorProfile)

        {

        id = OperatorProviderIdFromAppId( aApplicationId );

        }

    else

        {

        id = ProviderIdFromAppId( aApplicationId );

        }

    return id;

    }

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

// TUtil::OperatorProviderIdFromAppId

//

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

//

TInt TUtil::OperatorProviderIdFromAppId(TInt aApplicationId)

    {

    TInt id = KErrNotFound;

    CRepository* repository = NULL;

    TInt err = KErrNotFound;

    TRAP(err, repository = CRepository::NewL(KCRUidOperatorDatasyncInternalKeys));

    if (err == KErrNone)

        {

        switch (aApplicationId)

            {

             // Operator specific version of Contacts adapter is supported

            case EApplicationIdContact:

                {

                err = repository->Get(KNsmlOpDsOperatorAdapterUid, id);

                break;

                }

            default:

                {

                id = ProviderIdFromAppId(aApplicationId);

                break;

                }

            }

         delete repository;

        }

    if ( (id == KErrNotFound) || (err != KErrNone) || (id == 0) )

        {

        // Use default adapter

        id = ProviderIdFromAppId(aApplicationId);        

        }

    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;

		}

	if (id == KErrNotFound) // Check if this operator specific adapter

	    {

	    id = AppIdFromOperatorSpecificProviderId( aAdapterId );

	    }

	return id;

	}

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

// TUtil::AppIdFromOperatorSpecificProviderId

//

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

//

TInt TUtil::AppIdFromOperatorSpecificProviderId(TInt aAdapterId)

    {

    TInt id=KErrNotFound;

    CRepository* repository = NULL;

    TRAPD(err, repository = CRepository::NewL(KCRUidOperatorDatasyncInternalKeys));

    if (err == KErrNone)

        {

        TInt operatorContactsProvider = KErrNotFound;

        err = repository->Get(KNsmlOpDsOperatorAdapterUid, operatorContactsProvider);

        if ( err == KErrNone && aAdapterId == operatorContactsProvider )

            {

            id = EApplicationIdContact;

            }

        delete repository;

        }

    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);