/*

* Copyright (c) 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:  Utility classes.

*

*/

// INCLUDES

#include <SyncMLTransportProperties.h>

#include <eikenv.h>

#include <bautils.h>

#include <collate.h>

#include <StringLoader.h>

#include <avkon.rsg>

#include <DevManInternalCRKeys.h>

#include <centralrepository.h>

#include <SettingEnforcementInfo.h> // VSettingEnforcementInfo

#include <ecom/ecom.h>

#include "NSmlDMdef.h"

#include "NSmlDMSyncUtil.h"

#include "NSmlDMSyncDebug.h"

#include <featmgr.h>

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

 * class TUtil

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

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

// Panic

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

//

void TUtil::Panic(TInt aReason)

    {

	_LIT(KPanicCategory,"NSmlDMSyncUtil");

	User::Panic( KPanicCategory, aReason ); 

    }

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

// StrCopy

// String copy with lenght check.

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

//

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

    {

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

    }

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

// StrCopy

// String copy with lenght check.

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

//

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

    {

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

    }

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

// StrCopy

// String copy with lenght check.

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

//

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

    {

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

    }

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

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

		}

    }

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

// StrInsert

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

//

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

    {

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

	if (aSource.Length() <= free)

		{

		aTarget.Insert(0, aSource);

		}

    }

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

// StrToInt

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

//

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

	{

    TLex lex( aText );

    TInt err = lex.Val( aNum ); 

	return err;

	}

//

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

// 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 index=0; index < len; index++ )

		{

		TChar character = aText[index];

		if ( !character.IsSpace() )

			{

			return EFalse;

			}

		}

	return ETrue;

	}

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

// SyncTimeLC

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

//

HBufC* TUtil::SyncTimeLC( TTime aLastSync )

	{

	FLOG( "[OMADM] TUtil::SyncTimeLC" );

	TTime homeTime = ConvertUniversalToHomeTime( aLastSync );

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

	TPtr ptr = hBuf->Des();

	if ( IsToday( homeTime ) )

		{

		FLOG( "[OMADM] TUtil::SyncTimeLC time" );

		TBuf<KBufSize> timeFormat;

		HBufC* buf = StringLoader::LoadLC( R_QTN_TIME_USUAL_WITH_ZERO );

		TUtil::StrCopy( timeFormat, *buf );

		CleanupStack::PopAndDestroy( buf );

		homeTime.FormatL( ptr, timeFormat );

		FLOG( "[OMADM] TUtil::SyncTimeLC time done" );

		}

	else

		{

		FLOG( "[OMADM] TUtil::SyncTimeLC date" );

		TBuf<KBufSize> dateFormat;

        HBufC* buf = StringLoader::LoadLC( R_QTN_DATE_USUAL_WITH_ZERO );

        TUtil::StrCopy( dateFormat, *buf );

        CleanupStack::PopAndDestroy( buf );

		homeTime.FormatL(ptr, dateFormat);

		FLOG( "[OMADM] TUtil::SyncTimeLC date done" );

		}

    FLOG( "[OMADM] TUtil::SyncTimeLC Done" );

	return hBuf;

	}

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

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

    }

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

// IsToDay

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

//

TBool TUtil::IsToday(TTime aTime)

	{

	FLOG( "[OMADM] TUtil::IsToday" );

	TTime now;

	now.HomeTime();

	TInt day1 = now.DayNoInYear();

	TInt day2 = aTime.DayNoInYear();

	TTimeIntervalDays daysBetween = now.DaysFrom( aTime );

	if ( day1 != day2 )

		{

		FLOG( "[OMADM] TUtil::IsToday False 1" );

		return EFalse;

		}

	if ( daysBetween.Int() > 0 )

		{

		FLOG( "[OMADM] TUtil::IsToday False 2" );

		return EFalse;

		}

    FLOG( "[OMADM] TUtil::IsToday True" );

	return ETrue; 

	}

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

// TUtil::GetDateTextL

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

//

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

	{

	TTime homeTime = ConvertUniversalToHomeTime( aDateTime );

	HBufC* hBuf = StringLoader::LoadLC( 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 = StringLoader::LoadLC( 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::SettingEnforcementStateL

// 

// Checks if setting enforcement is activated.

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

TBool TUtil::SettingEnforcementStateL()

    {

FeatureManager::InitializeLibL();

if(!FeatureManager::FeatureSupported(KFeatureIdSapPolicyManagement))

{

		FeatureManager::UnInitializeLib();

		    return EFalse;

}

else

{

	FeatureManager::UnInitializeLib();

	CSettingEnforcementInfo* info = CSettingEnforcementInfo::NewL();

	CleanupStack::PushL(info);

	TBool active = EFalse;

	User::LeaveIfError(info->EnforcementActive(ESyncMLEnforcement, active));

	CleanupStack::PopAndDestroy(info);

	return active;

}

    }

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

// TUtil::SettingEnforcementState

// 

// Checks if setting enforcement is activated.

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

TBool TUtil::SettingEnforcementState()

    {

    TBool ret = EFalse;

    TRAP_IGNORE(ret = SettingEnforcementStateL());

    return ret;

    }

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

//  TUtil::iDMNotifier

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

CDMNativeNotifier* TUtil::iDMNotifier=NULL;

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

// TUtil::ShowDialogBox

// 

// Shows the requested dialog

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

TInt TUtil::ShowNativeDialogL(TInt aOperation)

    {

    CRepository* centrep = NULL;

    TInt disclaimerAccepted(0);

    RImplInfoPtrArray dmImplArray;

    CleanupClosePushL(dmImplArray);

    CDMNativeNotifier::ListImplementationsL(dmImplArray);

    TInt rval = -1;

    switch(aOperation)

        {

        case EPrivacyPolicy:

            {  

            //Check for implementations and set cenrep if count = 0 

            if( dmImplArray.Count() == 0 )  //No implementations found

                { 

                centrep = CRepository::NewLC( KCRUidDeviceManagementInternalKeys );

                if(centrep)

                    {

                    centrep->Get( KDMDisclaimerAccepted , disclaimerAccepted );

                    if(disclaimerAccepted != EDMDialogNotAccepted)

                        { 

                          disclaimerAccepted=1;

                          centrep->Set( KDMDisclaimerAccepted , disclaimerAccepted ); //for Disclaimer

                        }

                    CleanupStack::PopAndDestroy(centrep); 

                    dmImplArray.ResetAndDestroy();

                    CleanupStack :: PopAndDestroy(&dmImplArray);

                    return KErrNone ;

                    }    

                }

            TUid id( dmImplArray[0]->ImplementationUid());

            dmImplArray.ResetAndDestroy();

            CleanupStack :: PopAndDestroy(&dmImplArray);

            centrep = CRepository::NewLC( KCRUidDeviceManagementInternalKeys );

            if (centrep ) 

               {          

               centrep->Get( KDMDisclaimerAccepted , disclaimerAccepted ); //for Disclaimer

               CleanupStack::PopAndDestroy(centrep);

               }

            if(disclaimerAccepted==EDMDialogAccepted)

                {

                return KErrNone;

                }

            else

                {

                if(iDMNotifier == NULL)

                    {

                    iDMNotifier = CDMNativeNotifier::NewL(id);

                    }

                if(disclaimerAccepted==EDMDialogActive)

                    {

                    rval = iDMNotifier->ShowDialogL(EPrivacyPolicy);

                    }

                else if(disclaimerAccepted==EDMDialogNotAccepted)

                    {

                    rval = iDMNotifier->ShowDialogL(EPrivacyPolicy);

                    delete iDMNotifier;

                    iDMNotifier=NULL;      

                    REComSession::FinalClose();

                    }

                }

            break;

            } 

        }

    return rval;

    }

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

 * class TURIParser

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

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

// Constructor

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

//

TURIParser::TURIParser( const TDesC& aStr ) : iOriginalStr( aStr )

    {

    SkipHttp();

    }

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

// GetUriWithoutPort

// URI format: "http://serveraddress/documentname/"

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

//

void TURIParser::GetUriWithoutPort( TDes& aText )

	{

	aText = KNullDesC;

	TPtrC http = ParseHttp();

	TPtrC address = ParseAddress();

	TPtrC document = ParseDocument();

	TUtil::StrAppend( aText, http );

	TUtil::StrAppend( aText, address );

	if (document.Length() > 0)

		{

		TUtil::StrAppend( aText, KSlash );

		TUtil::StrAppend( aText, document );

		}

	else if ( iSlash )

		{

		TUtil::StrAppend( aText, KSlash );

		}

	}

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

// GetURI

// URI format: "http://serveraddress:port/documentname/"

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

//

void TURIParser::GetUri( TDes& aText, const TInt aPort )

	{

	aText = KNullDesC;

	TPtrC http = ParseHttp();

	TPtrC address = ParseAddress();

	TPtrC document = ParseDocument();

	TUtil::StrAppend( aText, http );

	TUtil::StrAppend( aText, address );

	TBuf<KBufSize32> buf;

	buf.Num( aPort );

	TUtil::StrAppend( aText, KColon );

	TUtil::StrAppend( aText, buf );

	if ( document.Length() > 0 )

		{

		TUtil::StrAppend( aText, KSlash );

		TUtil::StrAppend( aText, document );

		}

	else if ( iSlash )

		{

		TUtil::StrAppend( aText, KSlash );

		}

	}

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

// Port

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

//

TInt TURIParser::Port()

	{

	TInt port = KErrNotFound;

	TInt err = ParsePort( port );

	if ( err != KErrNone )

		{

		return KErrNotFound;

		}

	return port;

	}

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

// DefaultPort

// 

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

//

TInt TURIParser::DefaultPort()

	{

	TInt pos = iOriginalStr.FindF( KHttpsHeader );

	if ( pos != KErrNotFound )

		{

		return KDefaultHttpsPort;

		}

	return KDefaultHttpPort;

	}

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

// SkipHttp

// Set pointer to the end of "http://".

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

//

void TURIParser::SkipHttp()

	{

    TInt start = KErrNotFound;

    TInt end   = KErrNotFound;

    TStr str(iOriginalStr);

    GetHttpPos( start, end );

    if ( start != KErrNotFound )

    	{

    	iPtr.Set( str.Right( end + 1 ) );

    	}

    else

    	{

    	iPtr.Set( str.Right(0) );

    	}

	}

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