1 // Copyright (c) 1999-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 #ifdef _DEBUG

    17 #undef _MSG_NO_LOGGING

    18 #endif

    19 

    20 #include <msvschedulesend.h>

    21 

    22 #include <msventry.h>

    23 #include <msvids.h>

    24 #include <bautils.h>

    25 #include <e32property.h>

    26 #include <centralrepository.h>

    27 

    28 #include <msvschedulesettings.h>

    29 #include <msvoffpeaktime.h>

    30 #include <msvsysagentaction.h>

    31 #include <schsend_panic.h>

    32 #include <tmsvschedulesettingsutils.h>

    33 #include <schinfointernal.h>

    34 

    35 #ifndef _MSG_NO_LOGGING

    36 #include <flogger.h>

    37 #endif

    38 

    39 

    40 _LIT(KSchSendExe, "schsendexe.exe");

    41 

    42 LOCAL_C TBool operator==(const CArrayFixFlat<TTaskSchedulerCondition>& aConditions1, const CArrayFixFlat<TTaskSchedulerCondition>& aConditions2)

    43 	{

    44 	TInt count1 = aConditions1.Count();

    45 	TInt count2 = aConditions2.Count();

    46 	

    47 	// Compare the conditions.	

    48 	if( count1 != count2 )

    49 		{

    50 		// Different number of conditions - no match.

    51 		return EFalse;

    52 		}

    53 		

    54 	// Search for all the conditions in info1 are in info2

    55 	for( TInt ii = 0; ii < count1; ++ii )

    56 		{

    57 		TTaskSchedulerCondition condition1 = aConditions1[ii];

    58 		TTaskSchedulerCondition condition2;

    59 		TBool found = EFalse;

    60 		TInt jj = 0;

    61 		while( !found && jj < count2 )

    62 			{

    63 			condition2 = aConditions2[jj];

    64 			

    65 			if( condition2.iKey == condition1.iKey )

    66 				found = ETrue;

    67 			else

    68 				++jj;

    69 			}

    70 		if( !found || condition2.iState != condition1.iState || condition2.iType != condition1.iType )

    71 			{

    72 			// Either aConditions2 has not got this condition or it has but it 

    73 			// does not match - no match.

    74 			return EFalse;

    75 			}

    76 		}

    77 	return ETrue;

    78 	}

    79 

    80 /**

    81 Constructor.

    82 

    83 @param aServerEntry 

    84 The CMsvServerEntry of the server MTM of which this CMsvScheduleSend 

    85 object is a member.

    86 */

    87 EXPORT_C CMsvScheduleSend::CMsvScheduleSend(CMsvServerEntry& aServerEntry)

    88 	: iServerEntry(aServerEntry)

    89 	{

    90 	}

    91 

    92 /**

    93 Second phase constructor.

    94 

    95 This constructor creates instances of the following classes: 

    96 CMsvScheduleSettings, CMsvOffPeakTimes, CMsvSendErrorActions,

    97 CMsvSysAgentActions and CMsvScheduledEntries.

    98 */

    99 EXPORT_C void CMsvScheduleSend::ConstructL()

   100 	{

   101 	iSettings			= CMsvScheduleSettings::NewL();

   102 	iOffPeakTimes		= new (ELeave) CMsvOffPeakTimes();

   103 	iErrorActions		= CMsvSendErrorActions::NewL();

   104 	iAgentActions		= new (ELeave) CMsvSysAgentActions();

   105 	iSchEntries			= new (ELeave) CMsvScheduledEntries(KMsvSchsendArrayGrowth);

   106 

   107 	iSchEntryInfo		= new (ELeave) CArrayFixFlat<TScheduleEntryInfo2>(KMsvSchsendArrayGrowth);

   108 	iSchTaskInfo		= new (ELeave) CArrayFixFlat<TTaskInfo>(KMsvSchsendArrayGrowth);

   109 	}

   110 

   111 /**

   112 Destructor.

   113 */

   114 EXPORT_C CMsvScheduleSend::~CMsvScheduleSend()

   115 	{

   116 	delete iSettings;

   117 	delete iOffPeakTimes;

   118 	delete iErrorActions;

   119 	delete iAgentActions;

   120 

   121 	if (iScheduler.Handle())

   122 		iScheduler.Close();

   123 

   124 	if (iSchEntries)

   125 		iSchEntries->ResetAndDestroy();

   126 

   127 	delete iSchEntries;

   128 

   129 	delete iSchTaskInfo;

   130 	delete iSchEntryInfo;

   131 	}

   132 

   133 /**

   134 Schedules messages on the task scheduler.

   135 

   136 Messages that are successfully scheduled have their sending state set to

   137 KMsvSendStateScheduled.

   138 

   139 @param aSelection 

   140 Array of message IDs that need to be scheduled. This array cannot be empty.

   141 All the messages identified in the selection must belong to the same MTM;

   142 be scheduled for the same time; have the same setting for their OffPeak() 

   143 flag; have the scheduled time stored in the iDate member of their 

   144 corresponding TMsvEntry. 

   145 

   146 @param aPackage 

   147 Scheduling options

   148 

   149 @leave Any error code but KErrLocked and KErrNotFound

   150 The method overloading CMsvScheduledEntry::GetMessageL() left with an error,

   151 i.e. the scheduling info of one of the messages from the selection could not

   152 be retrieved from the message server.

   153 

   154 @leave Any error code

   155 Unable to reset the previous scheduling info for a message.

   156 

   157 @panic ScheduleSend-DLL 0

   158 The array of message IDs is empty.

   159 Debug build only.

   160 

   161 @panic ScheduleSend-DLL 1

   162 At least one of the selected messages is scheduled for a different time

   163 as the others.

   164 Debug build only.

   165 

   166 @panic ScheduleSend-DLL 2

   167 At least one of the selected messages does not belong to the same MTM.

   168 Debug build only.

   169 

   170 @panic ScheduleSend-DLL 3

   171 At least one of the selected messages does not have the same off-peak 

   172 settings as the others.

   173 Debug build only.

   174 */

   175 EXPORT_C void CMsvScheduleSend::ScheduleL(const CMsvEntrySelection& aSelection, const TMsvSchedulePackage& aPackage)

   176 	{

   177 	__ASSERT_DEBUG(aSelection.Count() > 0, gPanic(EMessageSelectionEmpty));

   178 

   179 	iPackage = aPackage;

   180 	GetMessagesL(aSelection);	//Leaves with KErrNotFound if there

   181 																	//are no messages returned in schEntries

   182 	TInt entryCount = iSchEntries->Count();

   183 	SCHSENDLOG(FLog(_L8("Asked to schedule %d msgs"), entryCount));

   184 	

   185 	if (entryCount)

   186 		{

   187 		TTime startTime;

   188 

   189 #if defined(_DEBUG)

   190 		CMsvScheduledEntry* firstEntry = (*iSchEntries)[0];

   191 #endif

   192 

   193 		while (entryCount--)

   194 			{

   195 			CMsvScheduledEntry* message = iSchEntries->At(entryCount);

   196 			__ASSERT_DEBUG(firstEntry->ScheduleDate() == message->ScheduleDate(), gPanic(EMessagesNotSameTime));

   197 

   198 			startTime = message->ScheduleDate();

   199 

   200 			// Reset previous scheduling info

   201 			DeleteScheduleForEntryL(*message);

   202 			ResetScheduleInfoForEntryL(*message, EFalse);

   203 			}

   204 

   205 		//Schedule the messages

   206 		DoScheduleL(*iSchEntries, KMsvSendStateScheduled, startTime, EFalse);

   207 		}

   208 	}

   209 

   210 /** 

   211 Determines when the messages should be re-scheduled on the task scheduler, 

   212 then schedules the messages at the new time(s).

   213 

   214 Messages that are successfully re-scheduled are updated. The pending conditions

   215 flag indicates whether the message has been schedule for a set of conditions 

   216 being met (or a timeout occuring) or scheduled for a specified time/date.

   217 

   218 NOTE - conditions scheduling is only supoprted from 8.1 onwards.

   219 

   220 In the case of time-scheduling, the date field is the scheduled time/date. In 

   221 the case of conditions-scheduling, the date field reflects the timeout value.

   222 

   223 There are several cases when messages are not re-scheduled. If all recipients 

   224 have been sent to - in this case the message's sending state set to 

   225 KMsvSendStateSent. If, more commonly, the message's maximum number of re-tries

   226 has been exceeded or the error action was ESendActionFail then the message is 

   227 not changed.

   228 

   229 @param aSelection 

   230 Array of message IDs that need to be re-scheduled. This array cannot be empty. 

   231 All the messages identified must belong to the same MTM. It is not a 

   232 precondition that each message has already been scheduled on the task 

   233 scheduler.

   234 

   235 @param aPackage

   236 Scheduling options.

   237 

   238 @param aErrorAction

   239 The specific action to take with the messages. If this argument is omitted, 

   240 then ReScheduleL() uses the iError member of each TMsvEntry to find the 

   241 related TMsvSendErrorAction in iErrorActions.

   242 

   243 @panic ScheduleSend-DLL 0

   244 The array of message IDs is empty.

   245 Debug build only.

   246 */

   247 EXPORT_C void CMsvScheduleSend::ReScheduleL(const CMsvEntrySelection& aSelection, const TMsvSchedulePackage& aPackage, const TMsvSendErrorAction* aErrorAction)

   248 	{

   249 	__ASSERT_DEBUG(aSelection.Count() > 0, gPanic(EMessageSelectionEmpty));

   250 	iPackage = aPackage;

   251 	GetMessagesL(aSelection);

   252 

   253 	TInt entryCount = iSchEntries->Count();

   254 	SCHSENDLOG(FLog(_L8("Asked to re-schedule %d msgs"), entryCount));

   255 

   256 	if (entryCount)

   257 		{

   258 		TTime curTime;

   259 		curTime.UniversalTime();

   260 		curTime += iSettings->Latency();

   261 

   262 		while (entryCount--)

   263 			{

   264 			CMsvScheduledEntry* message = iSchEntries->At(entryCount);

   265 	

   266 			SCHSENDLOG(FLog(_L8("\tAttempting to Re-Schedule msg %d"), message->Id()));

   267 

   268 			if (!SetMessageStartTime(*message, curTime, aErrorAction))

   269 				{

   270 				SCHSENDLOG(FLog(_L8("\t\tCannot Re-Schedule msg %d (new sending state %d)"), message->Id(), message->SendingState()));

   271 				DeleteScheduleForEntryL(*message);

   272 				ResetScheduleInfoForEntryL(*message, ETrue);

   273 				delete message;

   274 				iSchEntries->Delete(entryCount);

   275 				}

   276 			}

   277 

   278 		//Send the messages if there are any left to send

   279 		if (iSchEntries->Count())

   280 			{

   281 			DoReScheduleL(*iSchEntries);

   282 			}

   283 		else

   284 			{

   285 			SCHSENDLOG(FLog(_L8("\tNo messages to Re-Schedule")));

   286 			}

   287 		}

   288 	}

   289 

   290 /**

   291 Delete the schedules for the specified messages from the task scheduler. 

   292 

   293 The messages themselves are not deleted.

   294 

   295 @param aSelection 

   296 Array of message IDs that need to be deleted from the task scheduler.

   297 

   298 @leave Any error code

   299 Unable to connect and register with the scheduler.

   300 

   301 @leave Any error code but KErrLocked and KErrNotFound

   302 The method overloading CMsvScheduledEntry::GetMessageL() left with an error,

   303 i.e. the scheduling info of one of the messages from the selection could not

   304 be retrieved from the message server.

   305 

   306 @leave Any error code

   307 Unable to reset the previous scheduling info for a message.

   308 */

   309 EXPORT_C void CMsvScheduleSend::DeleteScheduleL(const CMsvEntrySelection& aSelection)

   310 	{

   311 	ConnectAndRegisterL();

   312 

   313 	GetMessagesL(aSelection);

   314 

   315 	TInt entryCount = iSchEntries->Count();

   316 	SCHSENDLOG(FLog(_L8("Asked to delete schedule of %d msgs"), entryCount));

   317 

   318 	while (entryCount--)

   319 		{

   320 		CMsvScheduledEntry* message = iSchEntries->At(entryCount);

   321 		SCHSENDLOG(FLog(_L8("\tDelete schedule for msg %d (mtm %d, oldSendState %d, newSendState %d)"), message->Id(), message->Mtm().iUid, message->SendingState(), KMsvSendStateSuspended));

   322 		message->SetSendingState(KMsvSendStateSuspended);

   323 		DeleteScheduleForEntryL(*message);

   324 		ResetScheduleInfoForEntryL(*message, ETrue);

   325 		}

   326 	}

   327 

   328 /*

   329 	Sets the message's scheduled flag to EFalse

   330 	Resets the schedule data associated with each message

   331 	Resets the number of retries for each recipient

   332 	Stores the data and recipients (in a stream associated with the TMsvEntry)

   333 */

   334 void CMsvScheduleSend::SendingCompleteL(CMsvScheduledEntry& aMessage, const TBool aChangeEntry)

   335 	{

   336 	__ASSERT_DEBUG(iServerEntry.Entry().Id() == aMessage.Id(), gPanic(EServerEntryNotSetToCorrectEntry));

   337 	

   338 	aMessage.SetScheduled(EFalse);

   339 	aMessage.iData.Reset();

   340 	aMessage.RecipientsResetRetries();

   341 

   342 	if (aChangeEntry)

   343 		{

   344 		TMsvEntry entry = iServerEntry.Entry();

   345 		aMessage.Entry(entry);

   346 		User::LeaveIfError(iServerEntry.ChangeEntry(entry));

   347 		}

   348 

   349 	CMsvStore* store = iServerEntry.EditStoreL();

   350 	CleanupStack::PushL(store);

   351 	aMessage.StoreL(*store);

   352 	store->CommitL();

   353 	CleanupStack::PopAndDestroy(store); 

   354 	}

   355 

   356 /**

   357 Tells the scheduler that sending is complete.

   358 

   359 This method sets the messages's scheduled flag to false, resets the schedule

   360 data associated with each message and the number of retries for each 

   361 recipient and stores the data and recipients in a stream associated with 

   362 the TMsvEntry.

   363 

   364 @param aSelection 

   365 Messages that were either successfully sent or which failed all the attempts

   366 to send.

   367 */

   368 EXPORT_C void CMsvScheduleSend::SendingCompleteL(const CMsvEntrySelection& aSelection)

   369 	{

   370 	TInt count = aSelection.Count();

   371 

   372 	while (count--)

   373 		{

   374 		CMsvScheduledEntry* schEntry = GetMessageL(aSelection[count]);

   375 		CleanupStack::PushL(schEntry);

   376 		SendingCompleteL(*schEntry, ETrue);

   377 		CleanupStack::PopAndDestroy(); //schEntry

   378 		}

   379 	}

   380 

   381 /**

   382 Tells the scheduler that sending is complete.

   383 

   384 This function must be called when a message that had previously been scheduled 

   385 is either sent or has failed. This function:

   386 

   387 1. Deletes the TMsvEntryScheduleData associated with the message

   388 

   389 2. Sets the Scheduled flag to EFalse

   390 

   391 3. If required, calls ChangeEntry() on the message server entry

   392 

   393 Note: SendingCompleteL() does not change the sending state of each message, 

   394 nor delete each message from the task scheduler.

   395 

   396 @param aEntry 

   397 The message which was either successfully sent or which failed (all the 

   398 attempts) to send. It is not a precondition that the message has already 

   399 been scheduled on the task scheduler.

   400 

   401 @param aChangeEntry 

   402 If aChangeEntry is ETrue then SendingCompleteL() will call 

   403 CMsvServerEntry::ChangeEntry() to update the message on the message server. 

   404 

   405 @panic ScheduleSend-DLL 24

   406 The server entry is not set to the correct entry.

   407 Debug build only.

   408 */

   409 EXPORT_C void CMsvScheduleSend::SendingCompleteL(TMsvEntry& aEntry, const TBool aChangeEntry)

   410 	{

   411 	__ASSERT_DEBUG(iServerEntry.Entry().Id() == aEntry.Id(), gPanic(EServerEntryNotSetToCorrectEntry));

   412 

   413 	CMsvScheduledEntry* schEntry = GetMessageL(aEntry.Id());

   414 	CleanupStack::PushL(schEntry);

   415 

   416 	SendingCompleteL(*schEntry, EFalse);

   417 	schEntry->Entry(aEntry);

   418 

   419 	if (aChangeEntry)

   420 		{

   421 		User::LeaveIfError(iServerEntry.ChangeEntry(aEntry));

   422 		}

   423 

   424 	CleanupStack::PopAndDestroy(); //schEntry

   425 	}

   426 

   427 

   428 /**

   429 Loads schedule settings from CenRep

   430 

   431 @param aRepository 

   432 CenRep repository to load settings from

   433 */

   434 EXPORT_C void CMsvScheduleSend::LoadScheduleSettingsL(CRepository& aRepository)

   435 	{

   436 	TMsvScheduleSettingsUtils::LoadScheduleSettingsL(*iSettings, aRepository);

   437 	TMsvScheduleSettingsUtils::LoadOffPeakSettingsL(*iOffPeakTimes, aRepository);

   438 	TMsvScheduleSettingsUtils::LoadSendErrorSettingsL(*iErrorActions, aRepository);

   439 	TMsvScheduleSettingsUtils::LoadSysAgentSettingsL(*iAgentActions, aRepository);	

   440 	}

   441 

   442 /**

   443 Verifies that the schedule information stored in specified messages is the 

   444 same as that on the task scheduler.

   445 

   446 @param aSelection 

   447 Array of message IDs that need to be checked against the task scheduler.

   448 

   449 @panic ScheduleSend-DLL 0

   450 The array of message IDs is empty.

   451 Debug build only.

   452 */

   453 EXPORT_C void CMsvScheduleSend::CheckScheduleL(const CMsvEntrySelection& aSelection)

   454 	{

   455 	__ASSERT_DEBUG(aSelection.Count(), gPanic(EMessageSelectionEmpty));

   456 

   457 	GetMessagesL(aSelection);	//Leaves with KErrNotFound if there are no messages returned in iSchEntries

   458 	TInt entryCount = iSchEntries->Count();

   459 	SCHSENDLOG(FLog(_L8("Asked to check schedule for %d msgs"), entryCount));

   460 	

   461 	ConnectAndRegisterL();

   462 

   463 	while (entryCount--)

   464 		{

   465 		TBool found = EFalse;

   466 		TTsTime schTime;

   467 

   468 		CMsvScheduledEntry& sEntry = *iSchEntries->At(entryCount);

   469 

   470 		if (!sEntry.iData.IsReset())

   471 			{

   472 			TSchedulerItemRef ref;

   473 			TInt size = 0;

   474 			TTaskInfo info;

   475 			

   476 			TInt err = iScheduler.GetTaskDataSize(sEntry.iData.iTaskId, size);

   477 

   478 			if (!err)

   479 				{

   480 				HBufC* buf = HBufC::NewLC(size);

   481 				TPtr ptr = buf->Des();

   482 

   483 				User::LeaveIfError(iScheduler.GetTaskInfoL(sEntry.iData.iTaskId, info, ptr, ref, schTime));

   484 

   485 				CleanupStack::PopAndDestroy(buf);

   486 				found = ETrue;

   487 				}

   488 			else if (err != KErrNotFound)

   489 				{

   490 				User::Leave(err);

   491 				} 

   492 			} 

   493 			

   494 		if (iServerEntry.SetEntry(sEntry.Id()) == KErrNone)

   495 			{

   496 			TMsvEntry entry = iServerEntry.Entry();

   497 			TInt sendingState = entry.SendingState();

   498 

   499 			if (sendingState == KMsvSendStateScheduled || sendingState == KMsvSendStateResend || entry.Scheduled())

   500 				{

   501 				if (found)

   502 					{

   503 					entry.SetScheduled(ETrue);

   504 					entry.iDate = schTime.GetUtcTime();

   505 					User::LeaveIfError(iServerEntry.ChangeEntry(entry));

   506 					}

   507 				else

   508 					{

   509 					entry.SetScheduled(EFalse);

   510 					entry.SetSendingState(KMsvSendStateUnknown);

   511 					entry.iDate.UniversalTime();

   512 					User::LeaveIfError(iServerEntry.ChangeEntry(entry));

   513 					SendingCompleteL(sEntry, EFalse);

   514 					} 

   515 				} 

   516 			} 

   517 		} 

   518 	}

   519 

   520 /**

   521 Determines the schedule time for a message.

   522 

   523 The schedule time is determined by the error action. If no error action is

   524 supplied, then the error action is obtained from the iErrorActions. This is a 

   525 list of error codes associated with an error action. The error code with which

   526 the message failed to be sent is used to determine the error action from this

   527 list.

   528 

   529 This function also increments the number of re-tries that the message has 

   530 undergone.

   531 

   532 A value of ETrue is returned if the message can be sent or a value of EFalse if

   533 the message cannot be sent. 

   534 

   535 If the message can be sent, then its schedule date and pending conditions flag 

   536 are updated.

   537 

   538 @see CMsvScheduleSend::ReScheduleL().

   539 

   540 @param	aMessage

   541 The message to be re-scheduled.

   542 

   543 @param	aFromTime

   544 The current time. Used to calculate the absolute schedule time once the interval

   545 has been established.

   546 

   547 @param	aErrorAction

   548 The error action applied to the message. This can be NULL in which case the error

   549 action is obtained from iErrorActions.

   550 

   551 @return

   552 A value of ETrue if the message should be sent or EFalse if it should not

   553 */

   554 TBool CMsvScheduleSend::SetMessageStartTime(CMsvScheduledEntry& aMessage, const TTime& aFromTime, const TMsvSendErrorAction* aErrorAction)

   555 	{

   556 	TBool sendMsg = EFalse;

   557 	TMsvSendErrorAction action;

   558 

   559 	if( aErrorAction != NULL )

   560 		{

   561 		sendMsg = aMessage.CanSendToAnyRecipients(*aErrorAction);

   562 		action = *aErrorAction;

   563 		}

   564 	else 

   565 		{

   566 		sendMsg = aMessage.CanSendToAnyRecipients(*iErrorActions, action);

   567 		}

   568 

   569 	SCHSENDLOG(FLog(_L8("\t\tCanSendToAnyRecipients() ret %d"), sendMsg));

   570 

   571 	if( sendMsg )

   572 		{

   573 		// Increase the number of times this message has been retried.

   574 		if( action.iRetries != ESendRetriesInfinite )

   575 			{

   576 			aMessage.iData.IncreaseRetries();

   577 			aMessage.RecipientsIncreaseRetries();

   578 			}

   579 			

   580 		TBool retryConditionMet = action.iAction == ESendActionRetryConditionMet;

   581 		

   582 		if( retryConditionMet && aMessage.PendingConditions() )

   583 			{

   584 			// There are two cases in which the message being re-scheduled has 

   585 			// already been scheduled for pending conditions met and the error 

   586 			// action is retry when conditions met.

   587 			// 1.	The timeout has expired - current time exceeds the message's 

   588 			//		schedule time (assuming that the message has a timeout).

   589 			// 2.	The conditions were temporarily met and by the time the 

   590 			//		waiting message tried to be sent the conditions were no 

   591 			//		longer true.

   592 			if( aMessage.ScheduleDate()!= Time::MaxTTime() && aFromTime > aMessage.ScheduleDate() )

   593 				{

   594 				// Case 1 - the message should not be re-scheduled (this marks

   595 				// the message as failed).

   596 				sendMsg = EFalse;

   597 				}

   598 			// NOTE - the else is case 2; the message should be re-scheduled,

   599 			// but the timeout value should NOT be re-calculated -> do nothing.

   600 			}

   601 		else

   602 			{

   603 			TTimeIntervalSeconds interval;

   604 			if( GetNextRetry(aMessage, action, interval) )

   605 				{

   606 				if( interval.Int() == 0 && retryConditionMet )

   607 					{

   608 					// The timeout was set to zero - set a schedule time of

   609 					// Time::MaxTTime().

   610 					aMessage.SetScheduleDate(Time::MaxTTime());

   611 					}

   612 				else

   613 					{

   614 					TTime schTime = aFromTime + interval;

   615 					RoundUpToMinute(schTime);

   616 					aMessage.SetScheduleDate(schTime);

   617 					}

   618 				aMessage.SetPendingConditions(retryConditionMet);

   619 				}

   620 			else

   621 				{

   622 				sendMsg = EFalse;

   623 				}

   624 

   625 			SCHSENDLOG(FLog(_L8("\t\tGetNextRetry() ret %d"), sendMsg));

   626 			}

   627 		}

   628 

   629 	if( !sendMsg )

   630 		{

   631 		TBool failed = ETrue;

   632 		TInt state	 = KMsvSendStateFailed;

   633 

   634 		if( aMessage.RecipientsAllSent() )

   635 			{

   636 			failed	= EFalse;

   637 			state	= KMsvSendStateSent;

   638 			}

   639 		else

   640 			{

   641 			aMessage.RecipientsSetFailed();

   642 			}

   643 

   644 		aMessage.SetFailed(failed);

   645 		aMessage.SetSendingState(state);

   646 		}

   647 

   648 	return sendMsg;

   649 	}

   650 

   651 /**

   652 Utility function that rounds a specified time up to the nearest minute.

   653 

   654 @param aTime 

   655 On return, the passed value rounded up to the nearest minute.

   656 */

   657 

   658 EXPORT_C void CMsvScheduleSend::RoundUpToMinute(TTime& aTime)

   659 	{

   660 	TDateTime dt(aTime.DateTime());

   661 

   662 	if (dt.MicroSecond() != 0 || dt.Second() != 0)

   663 		{

   664 		dt.SetMicroSecond(0);

   665 		dt.SetSecond(0);

   666 		aTime = dt;

   667 		aTime += (TTimeIntervalMinutes) 1;

   668 		}

   669 	}

   670 

   671 /*

   672 	Groups messages in aSchEntries by the date (time) they are to be scheduled

   673 	and if they are pending conditions met or not and then schedules each group.

   674 */

   675 

   676 void CMsvScheduleSend::DoReScheduleL(CMsvScheduledEntries& aSchEntries)

   677 	{

   678 	const TInt entryCount = aSchEntries.Count();

   679 	__ASSERT_DEBUG(entryCount > 0, gPanic(EMessageSelectionEmpty));

   680 

   681 	// Sort aSchEntries by CMsvScheduledEntry::iEntry.iDate and if they are 

   682 	// pending conditions or not.

   683 	SortByDateAndPendingConditionsL(aSchEntries);

   684 

   685 	//New selection of messages that will be used to store messages

   686 	//that are to be sent at the same time.

   687 	CMsvScheduledEntries* sel = new (ELeave) CMsvScheduledEntries(KMsvSchsendArrayGrowth);

   688 	CleanupStack::PushL(sel);

   689 

   690 	sel->SetReserveL(entryCount); // so following AppendL()s won't leave

   691 

   692 	CMsvScheduledEntry* curMessage = aSchEntries[0];

   693 	TTime lastTime = curMessage->ScheduleDate();

   694 	TBool lastPending = curMessage->PendingConditions();

   695 	sel->AppendL(curMessage);

   696 

   697 	// Delete old schedule

   698 	DeleteScheduleForEntryL(*curMessage);

   699 

   700 	for( TInt curMsg = 1; curMsg < entryCount; ++curMsg ) // must forward traverse the array

   701 		{

   702 		curMessage = aSchEntries[curMsg];

   703 		TTime thisTime = curMessage->ScheduleDate();

   704 		TBool thisPending = curMessage->PendingConditions();

   705 

   706 		// Delete old schedule

   707 		DeleteScheduleForEntryL(*curMessage);

   708 		if( thisTime == lastTime && lastPending == thisPending )

   709 			{

   710 			sel->AppendL(curMessage);

   711 			}

   712 		else

   713 			{

   714 			// Schedule the messages in the selection

   715 			DoScheduleL(*sel, KMsvSendStateResend, lastTime, lastPending);

   716 			sel->Reset(); // not ResetandDestroy because the messages are still in schEntries

   717 			sel->AppendL(curMessage);

   718 			lastTime = thisTime;

   719 			lastPending = thisPending;

   720 			}

   721 		}

   722 

   723 	if( sel->Count() )

   724 		{

   725 		// Schedule the remaining messages

   726 		DoScheduleL(*sel, KMsvSendStateResend, lastTime, lastPending);

   727 		}

   728 

   729 	sel->Reset(); // not ResetandDestroy because the messages are still in schEntries

   730 	CleanupStack::PopAndDestroy(sel);

   731 	}

   732 

   733 /*

   734 	Gets the Message ID stored against the task scheduler task aTaskId

   735 

   736 	@param aTaskId ID of task scheduler task

   737 */

   738 

   739 TMsvId CMsvScheduleSend::GetMessageIdForTaskL(TInt aTaskId)

   740 	{

   741 	TInt taskSize = 0;

   742 	TTaskInfo taskInfo;

   743 	TSchedulerItemRef taskSch;

   744 	TTsTime taskDue;

   745 

   746 	User::LeaveIfError(iScheduler.GetTaskDataSize(aTaskId, taskSize));

   747 

   748 	HBufC* taskData = HBufC::NewLC(taskSize);

   749 	TPtr ptr(taskData->Des());

   750 

   751  	User::LeaveIfError(iScheduler.GetTaskInfoL(aTaskId, taskInfo, ptr, taskSch, taskDue));

   752  

   753  	//Restore the TMsvSchedulePackage stored against the task scheduler task

   754  	TMsvSchedulePackage taskPackage;

   755  	taskPackage.UnpackL(taskInfo, *taskData);

   756  

   757  	CleanupStack::PopAndDestroy(taskData);

   758  

   759  	return taskPackage.iId;

   760  	}

   761  

   762 /*

   763 	Checks whether the message ID stored against task scheduler task aMessage.iData.iTaskId equals aMessage.Id().

   764 */

   765 

   766 TBool CMsvScheduleSend::TaskAndMessageMatchL(const CMsvScheduledEntry& aMessage)

   767 	{

   768 	TMsvId id = 0;

   769 	TRAPD(err, id = GetMessageIdForTaskL(aMessage.iData.iTaskId));

   770 

   771 	SCHSENDLOG(FLog(_L8("\tGetMessageIdForTask [taskId=%d err=%d id=%d aMessage.Id=%d"), aMessage.iData.iTaskId, err, id, aMessage.Id()));

   772 	TBool match = EFalse;

   773  

   774 	if (err == KErrNone)

   775 		{

   776 		match = (id == aMessage.Id());

   777 		}

   778 	else if (err != KErrNotFound)

   779 		{

   780 		User::Leave(err);

   781 		}

   782  

   783 	return match;

   784 	}

   785 	

   786 void CMsvScheduleSend::ResetScheduleInfoForEntryL(CMsvScheduledEntry& aMessage, const TBool aChangeEntry)

   787 	{

   788 	// Reset the scheduling info in the entry.

   789 	TMsvId oldId = iServerEntry.Entry().Id();

   790 	User::LeaveIfError(iServerEntry.SetEntry(aMessage.Id()));

   791 	SendingCompleteL(aMessage, aChangeEntry);	

   792 	iServerEntry.SetEntry(oldId); // ignore any error	

   793 	}

   794 	

   795 void CMsvScheduleSend::DeleteScheduleForEntryL(CMsvScheduledEntry& aMessage)

   796 	{

   797 	//Connect and register with the task scheduler

   798 	//Delete the task from the task scheduler

   799 	ConnectAndRegisterL();

   800 

   801 	if (TaskAndMessageMatchL(aMessage))

   802 		{

   803 		TInt err = iScheduler.DeleteTask(aMessage.iData.iTaskId);

   804 

   805 		SCHSENDLOG(FLog(_L8("\tDeleteTask Task=%d, Err=%d"), aMessage.iData.iTaskId, err));

   806 

   807 		if (err != KErrNotFound)

   808 			User::LeaveIfError(err);

   809 

   810 		//Delete the schedule if there are no more tasks assigned to it

   811 

   812 		//Declare variable to pass into GetScheduleL()

   813 		TScheduleState2 schState;

   814 		TTsTime schDueTime;

   815 

   816 		// Get the schedule Type

   817 		TScheduleType scheduleType;

   818 		iScheduler.GetScheduleTypeL(aMessage.iData.iRef.iHandle, scheduleType);

   819 		iSchTaskInfo->Reset();

   820 		

   821 		// Depends on the Schedule Type

   822 		if (scheduleType == ETimeSchedule)

   823 		    {

   824 			//Get details of the existing time schedule

   825 			err = iScheduler.GetScheduleL(aMessage.iData.iRef.iHandle, schState, *iSchEntryInfo, *iSchTaskInfo, schDueTime);

   826 

   827 			SCHSENDLOG(FLog(_L8("\tGetScheduleL Sch=%d, Err=%d"), aMessage.iData.iRef.iHandle, err));

   828 		    }

   829 

   830 		else if (scheduleType == EConditionSchedule)

   831 		    {

   832 		    CArrayFixFlat<TTaskSchedulerCondition>* schConditions =

   833 		        new (ELeave) CArrayFixFlat<TTaskSchedulerCondition>(KMsvSchsendArrayGrowth);

   834 

   835 		    CleanupStack::PushL(schConditions);

   836 			//Get details of the existing condition schedule

   837 		    err = iScheduler.GetScheduleL(aMessage.iData.iRef.iHandle, schState, *schConditions, schDueTime, *iSchTaskInfo);

   838 

   839 			SCHSENDLOG(FLog(_L8("\tGetScheduleL Sch=%d, Err=%d"), aMessage.iData.iRef.iHandle, err));

   840 

   841 		    CleanupStack::PopAndDestroy(schConditions);

   842 

   843 		    }

   844 		else

   845 		    {

   846 		    User::Leave(KErrNotFound);

   847 		    }

   848 		    

   849 		if (!err)

   850 			{

   851 			if (iSchTaskInfo->Count() == 0)

   852 				{

   853 				SCHSENDLOG(FLog(_L8("\tDeleting schedule %d"), aMessage.iData.iRef.iHandle));

   854 				iScheduler.DeleteSchedule(aMessage.iData.iRef.iHandle); //ignore error

   855 				}

   856 			}

   857 		else if (err != KErrNotFound)

   858 			{

   859 			User::Leave(err);

   860 			}

   861 		}

   862 	}

   863 

   864 /**

   865 Determines whether the message should be sent and if so the time interval (in

   866 seconds) that must elapse before aMessage should be sent.

   867 

   868 The time interval is determined by the error action supplied. In the case of an

   869 error action of ESendActionRetryConditionMet, the time interval indicates how

   870 long the message can be pending conditions to be met before the message is failed.

   871 

   872 The actual time period is defined in the iSettings object. This will be either

   873 iPendingConditionsTimeout, iShortInterval, iLongInterval or an element of 

   874 iVariableIntervals.

   875 

   876 If the message should be sent then a value of ETrue is returned. A value of 

   877 EFalse is returned if the message should not be sent. In this case the output

   878 argument aInterval is not valid.

   879 

   880 @param	aMessage

   881 The message to be re-scheduled.

   882 

   883 @param	aErrorAction

   884 The error action that determines the re-schedule behaviour.

   885 

   886 @param	aInterval

   887 An output argument that holds the time interval to when the message should be

   888 re-sent or when the message should be failed.

   889 

   890 @return

   891 A value of ETrue if the message should be sent or EFalse if it should not

   892 */

   893 TBool CMsvScheduleSend::GetNextRetry(CMsvScheduledEntry& aMessage, const TMsvSendErrorAction& aErrorAction, TTimeIntervalSeconds& aInterval) const

   894 	{

   895 	TBool retVal = (aErrorAction.iAction != ESendActionFail);

   896 	aInterval = 0;

   897 	

   898 	if( retVal )

   899 		{

   900 		if( aErrorAction.iAction == ESendActionRetryConditionMet )

   901 			{

   902 			// Interval given by the agent actions timeout value.

   903 			aInterval = iSettings->PendingConditionsTimeout().Int() * 60;

   904 			}

   905 		else if( aErrorAction.iAction == ESendActionRetryImmediately )

   906 			{

   907 			aInterval = iSettings->ShortInterval();

   908 			}

   909 		else

   910 			{

   911 			if( aErrorAction.iRetrySpacing == ESendRetrySpacingVariable )

   912 				{

   913 				//Retrieve the variable spacing associated with the retry count

   914 				const CArrayFixFlat<TTimeIntervalSeconds>& varIntervals = iSettings->VariableIntervals();

   915 				const TInt count = varIntervals.Count();

   916 				const TInt retry = aMessage.iData.Retries();

   917 

   918 				if( count == 0 )

   919 					{

   920 					aInterval = iSettings->LongInterval();

   921 					}

   922 				else if( retry < count )

   923 					{

   924 					aInterval = varIntervals[retry];

   925 					}

   926 				else

   927 					{

   928 					aInterval = varIntervals[count - 1];

   929 					}

   930 				}

   931 			else 

   932 				{

   933 				// Got here then aScheduleAction.iRetrySpacing == EStatic.

   934 				aInterval = iSettings->LongInterval();

   935 				}

   936 

   937 			__ASSERT_DEBUG(aInterval.Int() > 0, gPanic(ERetryIntervalMustByPositive));

   938 			}

   939 		}

   940 	return retVal;

   941 	}

   942 

   943 /**

   944 Searches the scheduler for an existing schedule item with a schedule time that

   945 matches with time supplied.

   946 

   947 @see RScheduler::GetScheduleL()

   948 

   949 @param aScheduler

   950 Handle to the scheduler.

   951 

   952 @param aStartTime

   953 Schedule start time.

   954 

   955 @param aRef

   956 On return, the schedule item.

   957 

   958 @leave KErrNotFound

   959 No schedule found matching the schedule time.

   960 */

   961 EXPORT_C void CMsvScheduleSend::FindScheduleL(RScheduler& aScheduler, const TTime& aStartTime, TSchedulerItemRef& aRef)

   962 	{

   963 	CArrayFixFlat<TScheduleEntryInfo2>* entryInfos = new (ELeave) CArrayFixFlat<TScheduleEntryInfo2>(1);

   964 	CleanupStack::PushL(entryInfos);

   965 

   966 	CArrayFixFlat<TTaskInfo>* taskInfos = new (ELeave) CArrayFixFlat<TTaskInfo>(1);

   967 	CleanupStack::PushL(taskInfos);

   968 

   969 	aRef.iHandle = KErrNotFound;

   970 

   971 	CArrayFixFlat<TSchedulerItemRef>* refs = new (ELeave) CArrayFixFlat<TSchedulerItemRef>(KMsvSchsendArrayGrowth);

   972 	CleanupStack::PushL(refs);

   973 

   974 	User::LeaveIfError(aScheduler.GetTaskRefsL(*refs, EAllSchedules, EMyTasks));

   975 

   976 	TInt count = refs->Count();

   977 	TScheduleState2 state;

   978 	TTsTime nextDue;

   979 

   980 	while (count-- && aRef.iHandle == KErrNotFound)

   981 		{

   982 		const TSchedulerItemRef& tempRef = (*refs)[count];

   983 

   984 		TScheduleType type;

   985 		User::LeaveIfError(aScheduler.GetScheduleTypeL(tempRef.iHandle, type));

   986 		if( type == ETimeSchedule )

   987 			{

   988 			entryInfos->Reset();

   989 			taskInfos->Reset();

   990 			const TInt err = aScheduler.GetScheduleL(tempRef.iHandle, state, *entryInfos, *taskInfos, nextDue);

   991 			if( err == KErrNone && nextDue.GetUtcTime() == aStartTime )

   992 				aRef = tempRef;

   993 			}

   994 		}

   995 

   996 	CleanupStack::PopAndDestroy(3, entryInfos);

   997 	if (aRef.iHandle == KErrNotFound)

   998 		User::Leave(KErrNotFound);

   999 	}

  1000 

  1001 /**

  1002 Searches the scheduler for an existing conditions schedule item with a set of 

  1003 pending conditions and timeout value that matches with those supplied.

  1004 

  1005 @see RScheduler::GetScheduleL

  1006 

  1007 @param aScheduler

  1008 Handle to the scheduler.

  1009 

  1010 @param aConditions

  1011 The set of System Agent conditions that are required to be met to trigger the

  1012 schedule.

  1013 

  1014 @param aTimeout

  1015 The timeout value for the schedule.

  1016 

  1017 @param aRef

  1018 On return, the schedule item.

  1019 

  1020 @leave KErrNotFound

  1021 No schedule found matching the schedule conditions and timeout.

  1022 */

  1023 EXPORT_C void CMsvScheduleSend::FindScheduleL(

  1024 								RScheduler&										aScheduler, 

  1025 								const CArrayFixFlat<TTaskSchedulerCondition>&	aConditions, 

  1026 								const TTime&									aTimeout, 

  1027 								TSchedulerItemRef& 								aRef)

  1028 	{

  1029 	CArrayFixFlat<TTaskSchedulerCondition>* schConditions = new (ELeave) CArrayFixFlat<TTaskSchedulerCondition>(KMsvSchsendArrayGrowth);

  1030 	CleanupStack::PushL(schConditions);

  1031 

  1032 	CArrayFixFlat<TTaskInfo>* taskInfos = new (ELeave) CArrayFixFlat<TTaskInfo>(1);

  1033 	CleanupStack::PushL(taskInfos);

  1034 

  1035 	aRef.iHandle = KErrNotFound;

  1036 

  1037 	CArrayFixFlat<TSchedulerItemRef>* refs = new (ELeave) CArrayFixFlat<TSchedulerItemRef>(KMsvSchsendArrayGrowth);

  1038 	CleanupStack::PushL(refs);

  1039 	

  1040 	User::LeaveIfError(aScheduler.GetTaskRefsL(*refs, EAllSchedules, EMyTasks));

  1041 

  1042 	TInt count = refs->Count();

  1043 	TScheduleState2 state;

  1044 	TTsTime nextTimeout;

  1045 	

  1046 	while( count-- && aRef.iHandle == KErrNotFound )

  1047 		{

  1048 		const TSchedulerItemRef& tempRef = (*refs)[count];

  1049 

  1050 		TScheduleType type;

  1051 		User::LeaveIfError(aScheduler.GetScheduleTypeL(tempRef.iHandle, type));

  1052 		if( type == EConditionSchedule )

  1053 			{

  1054 			taskInfos->Reset();

  1055 			const TInt err = aScheduler.GetScheduleL(tempRef.iHandle, state, *schConditions, nextTimeout, *taskInfos);

  1056 			if( err == KErrNone && nextTimeout.GetUtcTime() == aTimeout && *schConditions == aConditions )

  1057 				aRef = tempRef;

  1058 			}

  1059 		}

  1060 

  1061 	CleanupStack::PopAndDestroy(3, schConditions);

  1062 	if (aRef.iHandle == KErrNotFound)

  1063 		User::Leave(KErrNotFound);

  1064 	}	

  1065 

  1066 void CMsvScheduleSend::FindScheduleL(const TTime& aTime, const CArrayFixFlat<TTaskSchedulerCondition>& aSchConditions, TBool aPendingConditions, TSchedulerItemRef& aRef)

  1067 	{

  1068 	if( aPendingConditions )

  1069 		FindScheduleL(iScheduler, aSchConditions, aTime, aRef);

  1070 	else

  1071 		FindScheduleL(iScheduler, aTime, aRef);

  1072 	}

  1073 	

  1074 /**

  1075 Does the actual scheduling of the supplied messages.

  1076 

  1077 This function is called by ScheduleL() and DoReScheduleL(). The supplied messages

  1078 are assumed to have the values for the following data - MTM UID, off-peak flag,

  1079 schedule date and pending conditions flag. In debug mode, if these info is 

  1080 matching in all the messages then a panic will occur.

  1081 

  1082 @param	aSchEntries

  1083 An array with the messages to be scheduled.

  1084 

  1085 @param	aCommandId

  1086 The command id that must be used by the Send.Exe to eventually send the messages.

  1087 

  1088 @param	aFinalState

  1089 The sending state to set to the messages to if the message is successfully 

  1090 scheduled.

  1091 

  1092 @param	aTime

  1093 For conditions-scheduled messages this is the timeout, for time-scheduled messages

  1094 this is the scheduled time.

  1095 

  1096 @param 	aPendingConditions

  1097 A flag indicating whether the schedule should be pending conditions.

  1098 */

  1099 void CMsvScheduleSend::DoScheduleL(CMsvScheduledEntries& aSchEntries, const TInt aFinalState, const TTime& aTime, TBool aPendingConditions)

  1100 	{

  1101 	__ASSERT_DEBUG(aSchEntries.Count(), gPanic(EMessageSelectionEmpty));

  1102 	

  1103 #ifdef _DEBUG

  1104 	// Check that the mtm, time, off peak flag and pending conditions flag are 

  1105 	// the same for every message.

  1106 	TInt count = aSchEntries.Count();

  1107 	CMsvScheduledEntry* schEntry = aSchEntries[0];

  1108 

  1109 	while (count--)

  1110 		{

  1111 		CMsvScheduledEntry* entry = aSchEntries[count];

  1112 

  1113 		__ASSERT_DEBUG(entry->Mtm() == schEntry->Mtm(), gPanic(EMessagesNotSameMtm));

  1114 		__ASSERT_DEBUG((entry->OffPeak() && schEntry->OffPeak()) || (!entry->OffPeak() && !schEntry->OffPeak()), gPanic(EMessagesNotSameOffPeak));

  1115 		__ASSERT_DEBUG(entry->ScheduleDate() == schEntry->ScheduleDate(), gPanic(EMessagesNotSameTime));

  1116 		__ASSERT_DEBUG(entry->PendingConditions() == schEntry->PendingConditions(), gPanic(EMessagesNotSamePendingConditions));

  1117 		schEntry = entry;

  1118 		}

  1119 #endif

  1120 

  1121 	// Connect and register with the task scheduler

  1122 	ConnectAndRegisterL();

  1123 	

  1124 	// Determine the start time and validity period

  1125 	TTime latencyTime;

  1126 	latencyTime.UniversalTime();

  1127 	latencyTime += iSettings->Latency();

  1128 	TTime startTime = latencyTime;

  1129 

  1130 	if( aTime > startTime )

  1131 		{

  1132 		// The schedule time is in the future or there is no schedule time

  1133 		// (the messages are pending conditions) - update the start time.

  1134 		startTime = aTime;