/*

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

*

*/

#ifndef ASPUTIL_H

#define ASPUTIL_H

// INCLUDES

#include <e32base.h>

#include <ecom.h>

#include <eikenv.h> 

#include <ApSettingsHandlerUI.h>

#include <SyncMLClient.h>    // for RSyncMLSession

#include <SyncMLClientDS.h>  // for RSyncMLDataSyncProfile

#include <csch_cli.h> // RScheduler

#include "AspDefines.h"

// CONSTANTS

// FORWARD DECLARATIONS

class CAspProfile;

class CAspProfileList;

class CAspContentList;

class CAspTask;

class CAspFilter;

class CAspSchedule;

// CLASS DECLARATION

/**

* TAspParam

*

* This class is used as general parameter type.

*/

NONSHARABLE_CLASS (TAspParam)

	{

    public:

		// calling application id

		TInt iApplicationId;

		// profile id

		TInt iProfileId;

		// dialog mode

		TInt iMode;

		// general id number

		TInt iId;

		// return value to caller.

		TInt iReturnValue;

		// data provider id

		TInt  iDataProviderId;

		// sync task id

		TInt  iSyncTaskId;

		// sync profile

		CAspProfile* iProfile;

		// sync task

		CAspTask* iSyncTask;

		// sync filter

		CAspFilter* iSyncFilter;

		// session with sync server

		RSyncMLSession* iSyncSession;

		// profile list

		CAspProfileList* iProfileList;

		// content list

		CAspContentList* iContentList;

		//auto sync schedule setting

		CAspSchedule* iSchedule;

    public:

    	TAspParam(TInt aApplicationId);

		TAspParam(TInt aApplicationId, RSyncMLSession* aSyncSession);

	};

/**

* TAspUtil

* 

* This class contains general utility functions. 

*/

NONSHARABLE_CLASS (TUtil)

	{

    public:

        static void Panic(TInt aReason);

		static void StrCopy(TDes& aTarget, const TDesC& aSource);

		static void StrCopy(TDes& aTarget, const TDesC8& aSource);

		static void StrCopy(TDes8& aTarget, const TDesC& aSource);

		static HBufC* StrConversion(const TDesC& aText);

		static void StrAppend(TDes& aTarget, const TDesC& aSource);

		static void StrInsert(TDes& aTarget, const TDesC& aSource);

		static void Fill(TDes& aTarget, const TDesC& aOneCharStr, TInt aLength);

		static TInt StrToInt(const TDesC& aText, TInt& aNum);

		static TInt AddResFileL(const TDesC& aFile);

		static TBool IsEmpty(const TDesC& aText);

		static TInt ProviderIdFromAppId(TInt aApplicationId);

		static TInt ProviderIdFromAppId(TInt aApplicationId, TBool aOperatorProfile);

		static TInt OperatorProviderIdFromAppId(TInt aApplicationId);

		static TInt AppIdFromProviderId(TInt aAdapterId);

		static TInt AppIdFromOperatorSpecificProviderId(TInt aAdapterId);

		static TBool IsValidAppId(TInt aApplicationId);

		static TBool IsValidSID(TInt aApplicationId);

		static void GetDateTextL(TDes& aText, TTime aDateTime);

		static void GetTimeTextL(TDes& aText, TTime aDateTime);

		static HBufC* SyncTimeLC(TTime aLastSync);

		static void GetDateTimeTextL(TDes& aText, TTime aDateTime);

		static TBool IsToday(TTime aTime);

		static TTime ConvertUniversalToHomeTime(const TTime& aUniversalTime);

		static void LaunchHelpAppL();

		static void LaunchHelpAppL(CEikonEnv* aEikonkEnv);

		static TBool SettingEnforcementStateL();

		static TBool SettingEnforcementState();

		static CDesCArray* NumberConversionLC(CDesCArray* aList);

#ifdef _DEBUG		

    public:		

		static void GetMandatoryFieldText(TDes& aText, TInt aStatus);

		static void Print(const TDesC& aText);

		static void Print(const TDesC& aText, TInt aNum);

		static TTime TimeBefore();

		static TInt TimeAfter(TTime aBefore);

		static void TimeAfter(TTime aBefore, const TDesC& aText);

		static void GetApplicationName(TDes& aText, TInt aApplicationId);

#endif		

	};

/**

*  TStr contains descriptor operations with range checking.

*/

NONSHARABLE_CLASS (TStr)

    {

    public:

        TStr(const TDesC& aStr);

    public:

        TPtrC Mid(TInt aPos, TInt aLen);

        TPtrC Mid(TInt aPos);

        TPtrC Left(TInt aPos);

        TPtrC Right(TInt aPos);

        TPtrC Trim();

        TPtrC SubStr(TInt aStartPos, TInt aEndPos);

        TPtrC SubStrEx(TInt aStartPos, TInt aEndPos);

        TInt LastPos();

        TInt Len();

        TBool Compare(TInt aPos, TChar aChar);

        TInt Find(TInt aPos, TChar aChar);

    public:	

        TInt FirstNonSpace();

        TInt LastNonSpace();

    private:

        // reference to descriptor

		const TDesC& iStr;

    };

/**

*  TURIParser is used for parsing URI.

*/

NONSHARABLE_CLASS (TURIParser)

    {

    public:

    enum TDefaultPortNumber

	    {

	    EDefaultHttpPort = 80,

        EDefaultHttpsPort = 443

    	};

    enum TPortNumberRange

	    {

        EMinURIPortNumber = 1,

        EMaxURIPortNumber = 65535

    	};

    public:

        TURIParser(const TDesC& aStr);

    public:

        void GetUriWithoutPort(TDes& aText);

        void GetUriWithPort(TDes& aText, const TInt aPort);

        TInt Port();

        TInt DefaultPort();

        static TBool IsValidUri(const TDesC& aText);

        static TBool IsValidBluetoothHostAddress(const TDesC& aText);

        static TBool IsValidPort(const TInt aPort);

    private:

        TPtrC ParseHttp();

        TPtrC ParseAddress();

        TPtrC ParseDocument();

        TInt ParsePort(TInt& aPortNumber);

        TPtrC ParsePort();

     private:

        void GetHttpPos(TInt& aStartPos, TInt& aEndPos);

        void SkipHttp();

    private:

        // reference to original URI text

		const TDesC& iOriginalStr;

		// pointer to original URI text

		TPtrC iPtr;

    };

/**

*  TFlag contains integer flag operations.

*/

class TFlag

    {

    public:

        /**

        * C++ default constructor.

        */

        TFlag(TUint32& aFlag);

    public:

        /**

        * Turns given bit(s) on.

        * @since 2.5

        * @param aValue Bits to be turned on.

        * @return None.

        */

        void SetOn(const TUint32 aValue);

        /**

        * Turns given bit(s) off.

        * @since 2.5

        * @param aValue Bits to be turned off.

        * @return None.

        */

        void SetOff(const TUint32 aValue);

        /**

        * Checks if given bit(s) is/are set.

        * @since 2.5

        * @param aValue Bitmap to be checked.

        * @return None.

        */

        TBool IsOn(const TUint32 aValue) const;

    private:

		// reference to flag (integer)

        TUint32& iFlag;

    };

/**

* CAspIdleWait

* 

* This class is used for waiting synchronously until

* active scheduler has completed all pending events.

*/

NONSHARABLE_CLASS (CAspIdleWait) : public CBase

	{

    public:

        /**

        * Two-phased constructor.

        */

		static CAspIdleWait* NewL();

        /**

        * Destructor.

        */

		virtual ~CAspIdleWait();

    private:

        /**

        * C++ default constructor.

        */

		CAspIdleWait();

	public:

		/**

		* Waits until active schedure has nothing to do.

		* @param  None.

		* @return None.

		*/

		static void CAspIdleWait::WaitL();

    private:

        static TInt IdleCallback(TAny* aThisPtr);        

	private:

		CActiveSchedulerWait iWait;

	};

/**

* MAspActiveCallerObserver

*

* MAspActiveCallerObserver is for observing CAspActiveCaller.

*/

class MAspActiveCallerObserver

    {

    public:

	    virtual void HandleActiveCallL(TInt aCallId) = 0;

    };

/**

* CAspActiveCaller

*

* CAspActiveCaller is used for generating a call from active scheduler.

*/

NONSHARABLE_CLASS (CAspActiveCaller) : public CActive

    {

    public:

        /**

        * Two-phased constructor.

        */

        static CAspActiveCaller* NewL(MAspActiveCallerObserver* aObserver);

	    /**

        * Destructor.

        */

        virtual ~CAspActiveCaller();

    private:

        /**

        * C++ default constructor.

        */

	    CAspActiveCaller(MAspActiveCallerObserver* aObserver);

        /**

        * By default Symbian 2nd phase constructor is private.

        */

	    void ConstructL();

	public:

        /**

        * Calls observer using active object framework.

        * @param aCallId.

		* @param aMilliseconds Delay before observer is called.

        * @return None

        */

		void Start(TInt aCallId, TInt aMilliseconds);

        /**

        * Make active scheduler call RunL.

        * @param None

        * @return None

        */

		void Request();

    private:

        /**

        * From CActive. Called when asynchronous request completes.

        * @param None

        * @return None

        */

	    void RunL();

        /**

        * From CActive. Cancels asynchronous request.

        * @param None

        * @return None

        */

	    void DoCancel();

    private:

		// call that is passed to observer

		TInt iCallId;

		// timer

		RTimer iTimer;

		// observer that gets called

		MAspActiveCallerObserver* iObserver;

    };

/**

* TAspBearerItem 

*

*/

NONSHARABLE_CLASS (TAspBearerItem)

	{

	public:

		TInt iBearerType;

    	TBuf<KBufSize> iBearerName;

	};

/**

* CAspBearerHandler 

*

* CAspBearerHandler is for constructing list control for selecting

* bearer type (internet, bluetooth etc.)

*/

NONSHARABLE_CLASS (CAspBearerHandler) : public CBase

    {

    public:

        /**

        * Two-phased constructor.

        */

        static CAspBearerHandler* NewL(const TAspParam& aParam);

	    /**

        * Destructor.

        */

        virtual ~CAspBearerHandler();

    private:

        /**

        * C++ default constructor.

        */

	    CAspBearerHandler(const TAspParam& aParam);

        /**

        * By default Symbian 2nd phase constructor is private.

        */

	    void ConstructL();

	public:

	    /**

        * Finds out whether bearer type is supported.

		* @param aBearer Bearer type.

        * @return ETrue if supported, EFalse otherwise.

        */

		TBool IsSupported(TInt aBearer);

	    /**

        * Finds out bearer type for list item.

		* @param aIndex List index.

        * @return Bearer type.

        */

		TInt BearerForListIndex(TInt aIndex);

		/**

        * Finds out list position for aBearer.

		* @param aBearer.

        * @return List array index.

        */

		TInt ListIndexForBearer(TInt aBearer);

		/**

        * Creates supported bearer list.

		* @param None.

        * @return None.

        */

		void CreateSupportedBearerListL();

	    /**

        * Finds out default bearer for a device.

		* @param None.

        * @return Bearer type.

        */

		TInt DefaultBearer();

	    /**

        * Gets bearer name string.

		* @param aText.

		* @param aBearer.

        * @return None.

        */

		void GetBearerName(TDes& aText, TInt aBearerType);

	    /**

        * Builds array of bearer names for ui list control.

		* @param None.

        * @return Bearer name array.

        */

		CDesCArray* BuildBearerListLC();

	    /**

        * Finds out how many bearer types are supported.

		* @param None.

        * @return Bearer count.

        */

		TInt SupportedBearerCount();