/*

* Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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:    header file for CCseScheduleDB class*

*/

#ifndef _CCSESCHEDULEDB_H

#define _CCSESCHEDULEDB_H

#include <e32base.h>

#include <d32dbms.h>    // RDbStoreDatabase

#include <f32file.h>    // RFs

#include <s32file.h>

#include <babackup.h>

// CONSTANTS

const int KCseCustomSqlLength               = 256;

const int KCseDbCompactTimeout              = 30000000;

// Constant for filename definition

_LIT( KCseScheduleDBName, "CseSchedules.db" );

// Database table

_LIT( KCseDatabaseTable,                    "CseDatabase" );

_LIT( KCseDatabaseVersionCol,               "DbVersion" );

_LIT( KCseDatabaseReserved1Col,             "DbReserved1" );

_LIT( KCseDatabaseReserved2Col,             "DbReserved2" );

// Program table

_LIT( KCseScheduleTable, 					"ScheduleEvent" );

_LIT( KCseScheduleDbKeyCol, 				"Key" );

_LIT( KCseScheduleNameCol,					"Name" );

_LIT( KCseScheduleStartTimeCol,				"StartTime" );

_LIT( KCseScheduleEndTimeCol,				"EndTime" );

_LIT( KCseScheduleApplicationUIDCol, 		"ApplicationUID" );

_LIT( KCseSchedulePlugInUIDCol,    			"PlugInUID" );

_LIT( KCseScheduleTypeCol,					"Type" );

_LIT( KCseScheduleApplicationSpecificCol,	"ApplicationSpecificData" );

_LIT( KCseScheduleRunCountCol,              "ScheduleRunCount" );

_LIT( KCseScheduleStateCol,                 "ScheduleState" );

_LIT( KCseSchedulePluginTypeCol,            "PluginType" );

_LIT( KCseScheduleReserved1Col,             "ScheduleReserved1" );

_LIT( KCseScheduleReserved2Col,             "ScheduleReserved2" );

class CCseScheduledProgram;

/**  

* Version of CleanupXxxxPushL() that can be used to 'ResetAndDestroy'

* the supplied object if the clean-up stack unwinds.

*/

template <class T>

class CleanupResetAndDestroy

    {

    public:

        inline static void PushL( T& aRef );

    private:

        static void ResetAndDestroy( TAny *aPtr );

    };

template <class T>

    inline void CleanupResetAndDestroyPushL( T& aRef );

template <class T>

inline void CleanupResetAndDestroy<T>::PushL( T& aRef )

     {

     CleanupStack::PushL( TCleanupItem( &ResetAndDestroy, &aRef ) );

     }

template <class T>

void CleanupResetAndDestroy<T>::ResetAndDestroy( TAny *aPtr )

    {

    ( static_cast<T*>( aPtr ) )->ResetAndDestroy();

    }

template <class T>

inline void CleanupResetAndDestroyPushL( T& aRef )

    {

    CleanupResetAndDestroy<T>::PushL( aRef );

    }

/**

* Schedule database.

*/

class CCseScheduleDB : public CBase,

                       public MBackupObserver

{

	public:	// Constructors and destructors	

		virtual ~CCseScheduleDB();

		/**

        * Two-phased constructor.

        */

		IMPORT_C static CCseScheduleDB* NewL();

		/**

        * Enum for schedule state

        */

		enum TCseScheduleState

            {

            ECseWaiting = 0,

            ECseRunning            

            };

        /**

        * Enum for database access

        */    

        enum TCseDatabaseAccess

            {

            ECseDbOpen = 0,

            ECseDbLocked            

            };

    public: // Methods from MBackupObserver

        void ChangeFileLockL(const TDesC &aFileName, TFileLockFlags aFlags);

	public: // New methods

		/**

		* Adds given schedule to database. Method will leave with

		* KErrLocked -error code if Backup/Restore is going on.

		* @param	aData schedule to be added to database.

		* @return	None

		*/

		void AddScheduleL( CCseScheduledProgram& aData );

		/**

		* Removes schedule from database. Method will leave with

		* KErrLocked -error code if Backup/Restore is going on.

		* @param	aData schedule to be removed from database.

		* @return	None

		*/

		void RemoveScheduleL( const TUint32 aDbIdentifier );

		/**

		* Finds start time of the schedule that is happening next from the database.

		* Method will leave with KErrLocked -error code if Backup/Restore is going on.

		* @return	Start time of the next schedule.

		*/

		TTime GetNextScheduleTimeL();

		/**

		* Fills parameter array with schedules that have same starting time as

		* paramter time. Method will leave with KErrLocked -error code if

		* Backup/Restore is going on.

		* @param	aSchdeduleTime      Start time of the schedules fetched.

		* @param	aNextScheduleArray  Array containing schedules after call

		*                               is completed.

		* @return	None

		*/

		void FillScheduleArrayByTimeL( const TTime& aScheduleTime, 

			 		RPointerArray<CCseScheduledProgram>& aNextScheduleArray );

		/**

		* Gets the given schedule from database. Method will leave with

		* KErrLocked -error code if Backup/Restore is going on.

		* @param	aDbIdentifier       Database identifier of the schedule fetched.

		* @param	aSchedule           Pointer where schedule is stored when call

		*                               is completed.

		* @return	None

		*/	 						 

		void GetScheduleByDbIdentifierL( const TUint32 aDbIdentifier, 

                                         CCseScheduledProgram* aSchedule );

		/**

		* Get application specific schedules from db. Method will leave with

		* KErrLocked -error code if Backup/Restore is going on.

		* @param    aAppUid         Application UID.

		* @param    aScheduleArray  Array where to put scheduled events.

		* @return	None

		*/

		void GetApplicationSchedulesL( const TInt32 aAppUid, 

                                       RPointerArray<CCseScheduledProgram>& aArray );

		/**

		* Get overlapping schedules. Method will leave with

		* KErrLocked -error code if Backup/Restore is going on.

		* @param    aType           Schedule type (one from 

		* 		                    CCseScheduledProgram::TCseScheduleType)

		* @param    aStartTime      Start time

		* @param    aEndTime        End Time

		* @param    aResultArray    On return, contains pointers to overlapping schedules

		*               		    empty if none found.

		* @return   None.

		*/

		void GetOverlappingSchedulesL( const TInt32 aType, 

			                           const TTime& aStartTime,

			                           const TTime& aEndTime,

			                           RPointerArray<CCseScheduledProgram>& aResultArray );

		/**

		* Increases runcount of given schedule in DB. Method will leave with

		* KErrLocked -error code if Backup/Restore is going on.

		* @param    aDbIdentifier   Database identifier of the schedule thats

		*                           runcount is to be incremented		

		*/

		void IncreaseRunCountL( const TUint32 aDbIdentifier );

		/**

		* Gets the runcount of give schedule. Method will leave with

		* KErrLocked -error code if Backup/Restore is going on.

		* @param    aDbIdentifier   DbIdentifier of the schedule whos runcount is fetched.

		* @return   Run count of the schedule.

		*/

		TInt32 GetRunCountL( const TUint32 aDbIdentifier );

		/**

		* Gets the state of give schedule. Method will leave with

		* KErrLocked -error code if Backup/Restore is going on.

		* @param    aDbIdentifier   DbIdentifier of the schedule whos state is fetched.

		* @return   Schedule state (one of the CCseScheduledDB::TCseScheduleState)

		*/

		TInt32 GetScheduleStateL( const TUint32 aDbIdentifier );

		/**

		* Sets the state of give schedule. Method will leave with

		* KErrLocked -error code if Backup/Restore is going on.

		* @param    aDbIdentifier   DbIdentifier of the schedule whos state is fetched.

		* @param    aState          State to be set.

		* @return   None

		*/

		void SetScheduleStateL( const TUint32 aDbIdentifier,

                                const TInt32 aState );

        /**

		* Gets the startup schedules from the DB. When phone is set on, we try to run all

		* schdeulus that were on run when the phone was set off (run count is bigger than 0).

		* Method will leave with KErrLocked -error code if Backup/Restore is going on.

		* @param    aResultArray   Array where schedules that were on run are stored.

		* @return   None

		*/

        void StartupSchedulesL( RPointerArray<CCseScheduledProgram>& aResultArray );

        /**

		* Get plugin specific schedules from db. Method will leave with

		* KErrLocked -error code if Backup/Restore is going on.

		* @param    aPluginUid      Application UID.

		* @param    aScheduleArray  Array where to put scheduled events.

		* @return	None

		*/

        void GetSchedulesByPluginL( const TInt32 aPluginUid,

						            RPointerArray<CCseScheduledProgram>& aArray );

        /**

		* Get plugin specific schedules of specific type from db. Method will leave with

		* KErrLocked -error code if Backup/Restore is going on.

		* @param    aType           Schedule type

		* @param    aScheduleArray  Array where to put scheduled events.

		* @return	None

		*/

        void GetSchedulesByTypeL( const TInt32 aType,

						          RPointerArray<CCseScheduledProgram>& aArray );

        /**

		* Get schedules in given timeframe. Method will leave with

		* KErrLocked -error code if Backup/Restore is going on.	

		* @param    aBeginning      Start time of timeframe

		* @param    aEnd            End Time of timeframe

		* @param    aResultArray    On return, contains pointers to overlapping schedules

		*               		    empty if none found.

		* @return   None.

		*/

		void GetSchedulesByTimeframeL( const TTime& aStartTime,

			                           const TTime& aEndTime,

			                           RPointerArray<CCseScheduledProgram>& aResultArray );

        /**

		* Gets all the uid's of different plugins that are in DB.

		* KErrLocked -error code if Backup/Restore is going on.	

		* @param    aPlugins    On return, contains all the different plugin uid's in

		*               		db. Empty if none found.

		*/

		void GetPluginsL( RArray<TInt32>& aPlugins );

		/**

		* Get the next happening time of schedule from database based on plugin uid.

		* KErrLocked -error code if Backup/Restore is going on.	

		* @param    aPluginUid  Plugin uid in which to base the search

	    * @return   Next start time of the schedule of given plugin Uid.

		*/

		TTime GetNextScheduleTimeByPluginL( TInt32 aPluginUid );

		/**

		* Gets all the schedules that are going to happen at the given time based on plugin uid.

		* KErrLocked -error code if Backup/Restore is going on.	

		* @param    aScheduleTime       Start time in which to base the search

		* @param    aPluginUid          Plugin uid in which to base the search

		* @param    aNextScheduleArray  On return, contains pointers to schedules.

		*/

		void GetSchedulesByTimeAndPluginL( 

		                         const TTime& aScheduleTime, 

                                 TInt32 aPluginUid,

					             RPointerArray<CCseScheduledProgram>& aNextScheduleArray );

	private:

	    /**

        * C++ default constructor.        

        */

		CCseScheduleDB();

		/**

        * By default Symbian 2nd phase constructor is private.

        */

		void ConstructL();

	private: // Methods        

        /**

        * Checks the db version from db. If it is older than current one, destroy it

        * and create new one.

        * @return	None

        */

        void CheckDbVersionL();

        /**        

        * Open DB or create new database if DB file is not found. 

        * @return	None

        */

        void OpenOrCreateDbL();

    	/**

		* Create schedule table.

		* @param	aDatabase where to create schedule table.

		* @return	None

		*/

    	void CreateScheduleTableL( RDbStoreDatabase& aDatabase ) const;

    	/**

 		* Create database table.

 		* @param	aDatabase where to create database table.

 		* @return	None

 		*/

     	void CreateDatabaseTableL( RDbStoreDatabase& aDatabase );

     	/**

  		* Gets the database version number

  		* @param	None

  		* @return	None

  		*/

      	TInt GetDbVersionL(  );

     	/**

  		* Set hardcoded database version to database. Used after creating new database.

  		* @param	None

  		* @return	None

  		*/

      	void SetDatabaseVersionL();

        /**

        * Removes existing database.

        * @return   None

        */

		void RemoveDbL();

		/**

        * Static call back for CPeriodic.

        * @param    aThis   Pointer to CCseScheduleDB so that we can

        *                   direct call back to class. 

        * @return   Always TFalse

        */

		static TInt CompactCallback( TAny* aThis );

		/**

        * We want to compact database 30 seconds after last database operation.

        * this resets 30 sec counter.

        * @return   None

        */

		void ResetCompactTimer( );

		/**

        * Compacts database.

        * @return   None

        */

		void CompactDb();

		/**

        * Closed Db file and sets iDbAccess to ECseDbLocked.

        * @return   None

        */

		void CloseDbFile();

		/**

        * Closed Db file and sets iDbAccess to ECseDbOpen.

        * @return   None

        */

		void OpenDbFileL();

		/**

        * Leaves with KErrLocked if iDbAccess is ECseDbLocked.

        * @return   None

        */

		void LeaveIfDbLockedL() const;

	private: // Data

		/**

		* File server session is connected in construction and closed in

		* destruction

		*/

    	RFs iFsSession;

    	/**

    	* File name of the database which to handle

    	*/    	

		TFileName iDbFile;

		/**

		* For database operations

		*/

        RDbStoreDatabase iScheduleDb;

        /**

        * For creating and opening services database file. Own.

        */

        CFileStore* iScheduleFileStore;

        /**

        * Timer used in compacting database. Own.

        */

		CPeriodic* iCompactTimer;  

        /**

        * SQL string for SQL calls

        */

        TBuf<KCseCustomSqlLength> iSqlSchedule;

        /**

        * Status is database accessible

        */

        TCseDatabaseAccess iDbAccess;

        /**

        * Wrapper to get notification if backup/restore is

        * about to happen. Own.

        */

        CBaBackupSessionWrapper* iBackupWrapper;

};

#endif _CCSESCHEDULEDB_H