1 // Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 #include "SCHINFO.H"

    17 #include "SCHEXEC.H"

    18 

    19 /**

    20 Persists flag value, used by TScheduleState2

    21 @internalComponent

    22 */

    23 const TUint32 KPersists = 0x00000001;

    24 

    25 

    26 /**

    27 IsEnabled flag value, used by TScheduleState2

    28 @internalComponent

    29 */

    30 const TUint32 KIsEnabled = 0x00000002;

    31 

    32 

    33 EXPORT_C TTaskInfo::TTaskInfo(TInt aTaskId, TName& aName, TInt aPriority, TInt aRepeat)

    34 				:iRepeat(aRepeat), iTaskId(aTaskId), iName(aName), iPriority(aPriority)

    35 /** Constructor taking the specified parameters.

    36 

    37 @param aTaskId The task Id.

    38 @param aName The name of the task.

    39 @param aPriority The task priority.

    40 @param aRepeat How often the task is to be repeated */

    41 	{

    42 	} 

    43 

    44 EXPORT_C TTaskInfo::TTaskInfo()

    45 /** Default constructor. */

    46 	{

    47 	}

    48 

    49 EXPORT_C TTaskInfo& TTaskInfo::operator=(const TTaskInfo& aTaskInfo)

    50 	{

    51 	Mem::Copy(this,&aTaskInfo,sizeof(*this));

    52 	return *this;

    53 	}

    54 

    55 EXPORT_C void TTaskInfo::ExternalizeL(RWriteStream& aWriteStream) const

    56 /** Externalises an object of this class to a write stream.

    57 	

    58 	The presence of this function means that the standard templated operator<<() 

    59 	can be used to externalise objects of this class.

    60 	

    61 	@param aStream Stream to which the object should be externalised. */

    62 	{

    63 	aWriteStream << iName;

    64 	aWriteStream.WriteInt32L(iTaskId);

    65 	aWriteStream.WriteInt32L(iRepeat);

    66 	aWriteStream.WriteInt32L(iPriority);

    67 	}

    68 

    69 EXPORT_C void TTaskInfo::InternalizeL(RReadStream& aReadStream)

    70 	/** Internalises an object of this class from a read stream.

    71 	

    72 	The presence of this function means that the standard templated operator>>() 

    73 	can be used to internalise objects of this class.

    74 	

    75 	Note that the function has assignment semantics. It replaces the old value 

    76 	of the object with a new value read from the read stream.

    77 	

    78 	@param aStream Stream from which the object is to be internalised. */

    79 	{

    80 	aReadStream >> iName;

    81 	iTaskId = aReadStream.ReadInt32L();

    82 	iRepeat = aReadStream.ReadInt32L();

    83 	iPriority = aReadStream.ReadInt32L();

    84 	}

    85 

    86 //

    87 /**

    88 Externalizes the ScheduleEntryInfo

    89 @internalComponent only used by server

    90 */

    91 void TScheduleEntryInfo::ExternalizeL(RWriteStream& aStream) const

    92 	{

    93 	aStream.WriteInt32L(iValidityPeriod.Int());

    94 	aStream.WriteInt32L(iInterval);

    95 	aStream.WriteInt8L(iIntervalType);

    96 	TInt64 asInt = iStartTime.Int64();

    97 	aStream.WriteInt32L(I64LOW(asInt));

    98 	aStream.WriteInt32L(I64HIGH(asInt));

    99 	}

   100 

   101 /**

   102 Internalizes the ScheduleEntryInfo

   103 @internalComponent only used by server

   104 */

   105 void TScheduleEntryInfo::InternalizeL(RReadStream& aStream)

   106 	{

   107 	iValidityPeriod = aStream.ReadInt32L();

   108 	iInterval = aStream.ReadInt32L();

   109 	iIntervalType = TIntervalType(aStream.ReadInt8L());

   110 	TInt64 asInt;

   111 	TInt lo;

   112 	TInt hi;

   113 	lo=aStream.ReadInt32L();

   114 	hi=aStream.ReadInt32L();

   115 	asInt = MAKE_TINT64(hi,lo);

   116 	iStartTime = asInt;

   117 	}

   118 

   119 

   120 

   121 /**

   122 TScheduleEntryInfo2 Default constructor. 

   123 It sets the object's members data to the following default values.

   124 iIntervalType : EHourly

   125 iStartTime : UTC time set to 0

   126 iInterval : 0

   127 iValidityPeriod : 0

   128 */

   129 EXPORT_C TScheduleEntryInfo2::TScheduleEntryInfo2() :

   130 		iInterval(0),

   131 		iIntervalType(TIntervalType(0)),

   132 		iValidityPeriod(0),

   133 		iReserved(NULL)

   134 	{

   135 		

   136 	}

   137 	

   138 /**

   139 Copy constructor for TScheduleEntryInfo2

   140 Sets the parameter's data to this object.

   141 @param aEntryInfo The TScheduleEntryInfo2 object to be copied

   142 */	

   143 EXPORT_C TScheduleEntryInfo2::TScheduleEntryInfo2(const TScheduleEntryInfo2& aEntryInfo)

   144 	{

   145 	*this = aEntryInfo;

   146 	}

   147 

   148 /**

   149 TScheduleEntryInfo2 constructor taking the specified parameters.

   150 

   151 @param aStartTime The first time that the entry will cause execution of tasks

   152 @param aIntervalType Defines the type of time-frame relative to which execution of tasks is timed; 

   153 for example, EHourly implies relative to the current hour, EDaily implies 

   154 relative to the current day

   155 @param aInterval The interval between execution of tasks

   156 For a schedule entry interval to be valid, it should be greater than or equal to 1

   157 @param aIntervalMinutes The period for which the entry is valid

   158 */	

   159 EXPORT_C TScheduleEntryInfo2::TScheduleEntryInfo2(const TTsTime& aStartTime, TIntervalType aIntervalType, TInt aInterval, TTimeIntervalMinutes aValidityPeriod)

   160 	{

   161 	iStartTime = aStartTime;

   162 	iIntervalType = aIntervalType;

   163 	iInterval = aInterval;

   164 	iValidityPeriod = aValidityPeriod ;

   165 	iReserved = NULL;

   166 	}

   167 

   168 /**

   169 Returns the Interval Type

   170 @return The type of interval used between due times for this schedule entry.

   171 The type of interval used may be EHourly, EDaily, EMonthly or EYearly.

   172 @see TIntervalType

   173 */

   174 EXPORT_C TIntervalType TScheduleEntryInfo2::IntervalType() const

   175 	{

   176 	return iIntervalType;	

   177 	}

   178 

   179 /**

   180 Sets the type of interval used between due times for this schedule entry.

   181 The type of interval used may be EHourly, EDaily, EMonthly or EYearly.

   182 @param aIntervalType The type of interval to be used.

   183 @see TIntervalType

   184 */	

   185 EXPORT_C void TScheduleEntryInfo2::SetIntervalType(TIntervalType aIntervalType)

   186 	{

   187 	iIntervalType = aIntervalType;	

   188 	}

   189 

   190 /**

   191 Returns the first time at which the entry will cause execution of tasks.

   192 @return Start time - this TTsTime value may be either UTC or local time based.

   193 Entries with local time based start times will remain at that local time regardless of

   194 timezone or DST changes (ie. will float). Entries with UTC based start times, will

   195 remain at the given UTC time (will not float).

   196 @see TTsTime

   197 */

   198 EXPORT_C const TTsTime& TScheduleEntryInfo2::StartTime() const

   199 	{

   200 	return iStartTime;	

   201 	}

   202 

   203 /**

   204 Sets the first time the entry will cause execution of tasks.

   205 @param aStartTime This TTsTime value may be either UTC or local time based.

   206 If this is a local time based value, the schedule entry will remain

   207 at that local time regardless of timezone and DST changes (ie. it will float)

   208 If the value is UTC based, the schedule entry will remain at that UTC time (will not float).

   209 @see TTsTime

   210 */

   211 EXPORT_C void TScheduleEntryInfo2::SetStartTime(const TTsTime& aStartTime)

   212 	{

   213 	iStartTime = aStartTime;

   214 	}

   215 	

   216 /**

   217 Returns the interval between execution of tasks.

   218 @return Interval between execution of tasks. 

   219 For a schedule entry interval to be valid, it should be greater than or equal to 1.

   220 @see TScheduleEntryInfo2::SetInterval

   221 */	

   222 EXPORT_C TInt TScheduleEntryInfo2::Interval() const

   223 	{

   224 	return 	iInterval;

   225 	}

   226 

   227 /**

   228 Sets the interval between execution of tasks.

   229 The way that this value is interpreted depends on the value of iIntervalType. 

   230 For example, if the interval is 2 and iIntervalType has a value of EMonthly, 

   231 then the interval is 2 months. 

   232 @param aInterval For a schedule entry interval to be valid, it should be greater than or equal to 1.

   233 */	

   234 EXPORT_C void TScheduleEntryInfo2::SetInterval(TInt aInterval)

   235 	{

   236 	iInterval = aInterval;	

   237 	}

   238 

   239 /**

   240 Return the period for which the entry is valid.

   241 After the validity period has expired, tasks associated with the entry will 

   242 not be eligible for execution

   243 @return TTimeIntervalMinutes

   244 */

   245 EXPORT_C TTimeIntervalMinutes TScheduleEntryInfo2::ValidityPeriod() const

   246 	{

   247 	return iValidityPeriod;	

   248 	}

   249 	

   250 /**

   251 Sets the period for which the entry is valid.

   252 After the validity period has expired, tasks associated with the entry will 

   253 not be eligible for execution

   254 @param aValidityPeriod, the period for which the entry is valid

   255 @see TTimeIntervalMinutes

   256 */	

   257 EXPORT_C void TScheduleEntryInfo2::SetValidityPeriod(TTimeIntervalMinutes aValidityPeriod)

   258 	{

   259 	iValidityPeriod = aValidityPeriod;	

   260 	}

   261 

   262 

   263 /**

   264 Non exported constructor accepting a TScheduleEntryInfo parameter

   265 This constructor is provided for use with the deprecated APIs.

   266 This will assume home time in order to maintain backwards compatibility and will create a #

   267 TScheduleEntryInfo2 object with a local time based start time.

   268 @param aEntryInfo Entry info of deprecated type TScheduleEntryInfo

   269 @see TScheduleEntryInfo

   270 */

   271 TScheduleEntryInfo2::TScheduleEntryInfo2(const TScheduleEntryInfo& aEntryInfo)

   272 	{	

   273 	iStartTime.SetLocalTime(aEntryInfo.iStartTime);

   274 	iIntervalType = aEntryInfo.iIntervalType;

   275 	iInterval = aEntryInfo.iInterval;

   276 	iValidityPeriod = aEntryInfo.iValidityPeriod ;	

   277 	}

   278 

   279 

   280 /**

   281 Externalises an object of this class to a write stream.

   282 The presence of this function means that the standard templated operator<<() 

   283 can be used to externalise objects of this class.

   284 	

   285 @param aStream Stream to which the object should be externalised.

   286 @internalComponent only used by server

   287 */

   288 void TScheduleEntryInfo2::ExternalizeL(RWriteStream& aStream) const

   289 	{

   290 	aStream << iStartTime;

   291 	aStream.WriteInt32L(iIntervalType);	

   292 	aStream.WriteInt32L(iInterval);

   293 	aStream.WriteInt32L(iValidityPeriod.Int());	

   294 	}

   295 

   296 	

   297 /**

   298 Internalises an object of this class from a read stream.

   299 The presence of this function means that the standard templated operator>>() 

   300 can be used to internalise objects of this class.

   301 		

   302 @param aStream Stream from which the object is to be internalised.

   303 @internalComponent only used by server

   304 */	

   305 void TScheduleEntryInfo2::InternalizeL(RReadStream& aStream)

   306 	{

   307 	aStream >> iStartTime;

   308 	iIntervalType = TIntervalType(aStream.ReadInt32L());

   309 	iInterval = aStream.ReadInt32L();

   310 	iValidityPeriod = aStream.ReadInt32L();

   311 	}

   312 	

   313 /**

   314 Calls ProcessOffsetEvent() on TScheduleEntryInfo's start time member

   315 @see TTsTime::ProcessOffsetEvent

   316 @internalComponent only used by the server

   317 */

   318 void TScheduleEntryInfo2::ProcessOffsetEvent()

   319 	{

   320 	iStartTime.ProcessOffsetEvent();

   321 	}

   322 

   323 /**

   324 Assignment operator for TScheduleEntryInfo2

   325 @see Mem::Copy

   326 */

   327 EXPORT_C TScheduleEntryInfo2& TScheduleEntryInfo2::operator=(const TScheduleEntryInfo2& aEntryInfo)

   328 	{

   329 	Mem::Copy(this,&aEntryInfo,sizeof(*this));

   330 	return *this;

   331 	}

   332 	

   333 /**

   334 Default Constructor for TScheduleState2.

   335 By default, this state: has an empty string name, is non persistent, non enabled and its due time is set to zero.

   336 */

   337 EXPORT_C TScheduleState2::TScheduleState2():

   338 	iName(_L("")),

   339 	iFlags(0),

   340 	iReserved(NULL)

   341 	{

   342 		

   343 	}

   344 

   345 /**

   346 Copy constructor for TScheduleState2

   347 @param aScheduleState The TScheduleState2 object to be copied

   348 */	

   349 EXPORT_C TScheduleState2::TScheduleState2(const TScheduleState2& aScheduleState)

   350 	{

   351 	*this = aScheduleState;

   352 	}

   353 

   354 /**

   355 Constructor taking the specified parameters.

   356 @param	aName The name of the schedule

   357 @param 	aDueTime The time when the schedule is next due.

   358 @param 	aPersists Boolean to indicate whether the schedule is persistent or not.

   359 if a schedule is persistent, its lifetime is not limited to the lifetime of 

   360 the tasks associated with it.

   361 If a schedule is transient, it is created together with a new scheduled task, 

   362 and is destroyed when the task is destroyed

   363 @param 	aEnabled Boolean to indicate whether the shedule is enabled or not.

   364 */	

   365 EXPORT_C TScheduleState2::TScheduleState2(const TName& aName, const TTsTime& aDueTime, TBool aPersists, TBool aEnabled)

   366 	{

   367 	iName = aName;

   368 	iDueTime = aDueTime;

   369 	SetPersists(aPersists);

   370 	SetEnabled(aEnabled);

   371 	iReserved = NULL;

   372 	

   373 	}

   374 		

   375 /**

   376 @return  The name of the schedule

   377 */

   378 EXPORT_C const TName& TScheduleState2::Name() const

   379 	{

   380 	return iName;	

   381 	}

   382 	

   383 /**

   384 Sets the name of the schedule

   385 @param aName The name of the schedule

   386 */	

   387 EXPORT_C void TScheduleState2::SetName(const TName& aName)

   388 	{

   389 	iName = aName;	

   390 	}

   391 

   392 

   393 /**

   394 Returns the time when the schedule is next due.

   395 @return The time when the schedule is next due. This time could be either home time (for floating schedules) or UTC time.

   396 @see TTsTime

   397 */

   398 EXPORT_C const TTsTime& TScheduleState2::DueTime() const

   399 	{

   400 	return iDueTime;	

   401 	}

   402 

   403 	

   404 /**

   405 Sets the time when the schedule is next due.

   406 @param aDueTime The time when the schedule is next due. This time could be either home time (for floating schedules) or UTC time.

   407 @see TTsTime

   408 */	

   409 EXPORT_C void TScheduleState2::SetDueTime(const TTsTime& aDueTime)

   410 	{

   411 	iDueTime = aDueTime;

   412 	}

   413 

   414 

   415 /**

   416 Returns a boolean whether this schedule perists or not.

   417 @return Etrue if this schedule persists, EFalse if this schedule doen't persist.

   418 */

   419 EXPORT_C TBool TScheduleState2::Persists() const

   420 	{

   421 	return iFlags & KPersists ? ETrue: EFalse;		

   422 	}

   423 

   424 	

   425 

   426 /**

   427 Sets a boolean whether this schedule perists or not.

   428 @param aPersists Etrue if this schedule persits, EFalse if this schedule doen't persist.

   429 */	

   430 EXPORT_C void TScheduleState2::SetPersists(TBool aPersists)

   431 	{

   432 	if(aPersists )

   433 		iFlags |= KPersists;

   434 	else

   435 		iFlags &= ~KPersists;

   436 	}

   437 

   438 

   439 /**

   440 Returns information on whether this schedule is enabled or not.

   441 @return Etrue if the schedule is enabled, EFalse id the schedule is not enabled.

   442 */

   443 EXPORT_C TBool TScheduleState2::Enabled() const

   444 	{

   445 	return iFlags & KIsEnabled ? ETrue: EFalse;	

   446 	}

   447 

   448 	

   449 /**

   450 Sets information on whether this schedule is enabled or not.

   451 @param aEnabled 

   452 */	

   453 EXPORT_C void TScheduleState2::SetEnabled(TBool aEnabled)

   454 	{

   455 	if(aEnabled )

   456 		iFlags |= KIsEnabled;

   457 	else

   458 		iFlags &= ~KIsEnabled;	

   459 	}

   460 

   461 /**

   462 Assigns a TScheduleState2 to this object.

   463 @see Mem::Copy

   464 */

   465 EXPORT_C TScheduleState2& TScheduleState2::operator=(const TScheduleState2& aScheduleState)

   466 	{

   467 	Mem::Copy(this,&aScheduleState,sizeof(*this));

   468 	return *this;

   469 	}

   470 

   471 /**

   472 A constructor for TScheduleState that takes a TScheduleState2 parameter,

   473 for use with the deprecated APIs. All TScheduleStates created will have 

   474 local time based iDueTime data members.

   475 @internalComponent

   476 */

   477 TScheduleState::TScheduleState(const TScheduleState2& aScheduleState2)

   478 	{

   479 	iName = aScheduleState2.Name();	

   480 	iPersists = aScheduleState2.Persists();

   481 	iEnabled = aScheduleState2.Enabled();

   482 	

   483 	// iDueTime is local time based for backwards compatibility

   484 	iDueTime = aScheduleState2.DueTime().GetLocalTime();

   485 	}