1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/ossrv/genericservices/taskscheduler/SCHSVR/SCHEDULE.CPP Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,602 @@
1.4 +// Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies).
1.5 +// All rights reserved.
1.6 +// This component and the accompanying materials are made available
1.7 +// under the terms of "Eclipse Public License v1.0"
1.8 +// which accompanies this distribution, and is available
1.9 +// at the URL "http://www.eclipse.org/legal/epl-v10.html".
1.10 +//
1.11 +// Initial Contributors:
1.12 +// Nokia Corporation - initial contribution.
1.13 +//
1.14 +// Contributors:
1.15 +//
1.16 +// Description:
1.17 +//
1.18 +
1.19 +// User includes
1.20 +#include "SchLogger.h"
1.21 +#include "SCHEDULE.H"
1.22 +#include <schtask.h>
1.23 +#include "SCHCLI.H"
1.24 +#include "SCHENTRY.H"
1.25 +#include "SchTimer.h"
1.26 +#include "SCHEXEC.H"
1.27 +// Constants
1.28 +const TInt KMaxTasksPerSchedule = 9999;
1.29 +
1.30 +//TScheduledTask
1.31 +TScheduledTask::TScheduledTask(CScheduledTask& aTask, CClientProxy& aClient)
1.32 + : iTask(aTask),
1.33 + iClient(aClient)
1.34 + {
1.35 + }
1.36 +
1.37 +void TScheduledTask::OnDue(const TTsTime& aValidUntil)
1.38 + {
1.39 + LOGSTRING("TScheduledTask::OnDue - start");
1.40 + iTask.OnDue(aValidUntil);
1.41 + iClient.ReadyToExecute();
1.42 + LOGSTRING("TScheduledTask::OnDue - end");
1.43 + }
1.44 +
1.45 +const HBufC& TScheduledTask::Data() const
1.46 + {
1.47 + return iTask.Data();
1.48 + }
1.49 +
1.50 +const TTaskInfo& TScheduledTask::Info() const
1.51 + {
1.52 + return iTask.Info();
1.53 + }
1.54 +
1.55 +const CClientProxy& TScheduledTask::Client() const
1.56 + {
1.57 + return iClient;
1.58 + }
1.59 +
1.60 +void TScheduledTask::RemoveInfo()
1.61 + {
1.62 + LOGSTRING("TScheduledTask::RemoveInfo - start");
1.63 + iClient.RemoveTask(&iTask);
1.64 + LOGSTRING("TScheduledTask::RemoveInfo - end");
1.65 + }
1.66 +
1.67 +void TScheduledTask::DecRepeat()
1.68 + {
1.69 + iTask.DecRepeat();
1.70 + }
1.71 +
1.72 +TInt TScheduledTask::Offset()
1.73 + {
1.74 + return (_FOFF(TScheduledTask, iLink));
1.75 + }
1.76 +/*************************************************************************/
1.77 +//CSchedule functions
1.78 +/*************************************************************************/
1.79 +CSchedule* CSchedule::NewLC(TInt aHandle,
1.80 + const TDesC& aName,
1.81 + TBool aPersists,
1.82 + const CArrayFixFlat<TScheduleEntryInfo2>& aEntries,
1.83 + const TSecurityInfo& aSecurityInfo)
1.84 + {
1.85 + CSchedule* self = new(ELeave) CSchedule(aSecurityInfo, aHandle, aPersists);
1.86 + CleanupStack::PushL(self);
1.87 + self->ConstructL(aName, aEntries);
1.88 + return self;
1.89 + }
1.90 +
1.91 +CSchedule* CSchedule::NewLC(TInt aHandle,
1.92 + const TDesC& aName,
1.93 + TBool aPersists,
1.94 + const CArrayFixFlat<TTaskSchedulerCondition>& aEntries,
1.95 + const TTsTime& aDefaultRunTime,
1.96 + const TSecurityInfo& aSecurityInfo)
1.97 + {
1.98 + CSchedule* self = new(ELeave) CSchedule(aSecurityInfo, aHandle, aPersists);
1.99 + CleanupStack::PushL(self);
1.100 + self->ConstructL(aName, aEntries,aDefaultRunTime);
1.101 + return self;
1.102 + }
1.103 +
1.104 +CSchedule* CSchedule::NewL(CFileStore& aStore, TStreamId& aStreamId)
1.105 + {
1.106 + CSchedule* self = new(ELeave) CSchedule;
1.107 + CleanupStack::PushL(self);
1.108 + self->RestoreL(aStore, aStreamId);//get self from root
1.109 + CleanupStack::Pop();//self
1.110 + return self;
1.111 + }
1.112 +
1.113 +CSchedule::CSchedule(const TSecurityInfo& aSecurityInfo, TInt aHandle, TBool aPersists)
1.114 +: iId(aHandle),
1.115 + iPersists(aPersists),
1.116 + iEnabled(ETrue),
1.117 + iTaskList(TScheduledTask::Offset()),
1.118 + iEntryList(TScheduleEntry::Offset()),
1.119 + iSecurityInfo(aSecurityInfo)
1.120 + {
1.121 + }
1.122 +
1.123 +CSchedule::CSchedule()
1.124 +: iTaskList(TScheduledTask::Offset()),
1.125 + iEntryList(TScheduleEntry::Offset())
1.126 + {
1.127 + }
1.128 +
1.129 +CSchedule::~CSchedule()
1.130 + {
1.131 + LOGSTRING("CSchedule::~CSchedule - start");
1.132 +
1.133 + delete iName;
1.134 + RemoveTasks(EFalse);
1.135 + RemoveEntries();
1.136 + RemoveConditions();
1.137 +
1.138 + LOGSTRING("CSchedule::~CSchedule - end");
1.139 + }
1.140 +
1.141 +void CSchedule::ConstructL(const TDesC& aName,
1.142 + const CArrayFixFlat<TScheduleEntryInfo2>& aEntries)
1.143 + {
1.144 + iName = aName.AllocL();
1.145 + AddEntriesL(aEntries);
1.146 + }
1.147 +
1.148 +void CSchedule::ConstructL(const TDesC& aName,
1.149 + const CArrayFixFlat<TTaskSchedulerCondition>& aEntries,
1.150 + const TTsTime& aDefaultRunTime)
1.151 + {
1.152 + iName = aName.AllocL();
1.153 + AddConditionsL(aEntries);
1.154 +
1.155 + // we plug the default time in as the start time of a schedule entry
1.156 + TScheduleEntryInfo2 info(aDefaultRunTime, EDaily, 1, 60*24);
1.157 + TScheduleEntry* entry = ScheduleEntryFactory::CreateL(info);
1.158 + iEntryList.AddLast(*entry);
1.159 + }
1.160 +
1.161 +void CSchedule::RestoreL(CFileStore& aStore, TStreamId& aId)
1.162 + {
1.163 + RStoreReadStream scheduleStream;
1.164 + scheduleStream.OpenLC(aStore, aId);
1.165 + InternalizeL(scheduleStream);
1.166 + CleanupStack::PopAndDestroy(&scheduleStream);
1.167 + }
1.168 +
1.169 +TInt CSchedule::Offset()
1.170 + {
1.171 + return (_FOFF(CSchedule, iLink));
1.172 + }
1.173 +
1.174 +TBool CSchedule::ClientInSchedule(const TDesC& aClientName)
1.175 +//
1.176 +// returns true if the client is part of a task associated with this schedule
1.177 +//
1.178 + {
1.179 + TSglQueIter<TScheduledTask> tasks(iTaskList);
1.180 + tasks.SetToFirst();
1.181 + //
1.182 + TScheduledTask* task;
1.183 + while ((task=tasks++)!=NULL)
1.184 + {
1.185 + if (task->Client().ExecutorFileName().MatchF(aClientName) == 0)
1.186 + return ETrue;
1.187 + }
1.188 + return EFalse;
1.189 + }
1.190 +
1.191 +//
1.192 +//Task methods
1.193 +//
1.194 +
1.195 +void CSchedule::AddTask(TScheduledTask& aTask)
1.196 + {
1.197 + iTaskList.AddFirst(aTask);
1.198 + }
1.199 +
1.200 +void CSchedule::RemoveTasks(TBool aFromClient)
1.201 + {
1.202 + LOGSTRING("CSchedule::RemoveTasks - start");
1.203 +
1.204 + TScheduledTask* task;
1.205 + TSglQueIter<TScheduledTask> taskIter(iTaskList);
1.206 + taskIter.SetToFirst();
1.207 + while ((task = taskIter++) != NULL)
1.208 + {
1.209 + if (aFromClient)
1.210 + {
1.211 + task->RemoveInfo();
1.212 + }
1.213 + RemoveTask(task);
1.214 + }
1.215 +
1.216 + LOGSTRING("CSchedule::RemoveTasks - end");
1.217 + }
1.218 +
1.219 +void CSchedule::RemoveTask(TScheduledTask* aTask)
1.220 + {
1.221 + LOGSTRING("CSchedule::RemoveTask - start");
1.222 +
1.223 + LOGSTRING2("CSchedule::RemoveTask - Schedule id: %d", iId);
1.224 + iTaskList.Remove(*aTask);
1.225 + delete aTask;
1.226 + LOGSTRING("CSchedule::RemoveTask - end");
1.227 + }
1.228 +
1.229 +void CSchedule::NotifyTasks()
1.230 + {
1.231 + LOGSTRING("CSchedule::NotifyTasks - start");
1.232 +
1.233 + TScheduledTask* task;
1.234 + TSglQueIter<TScheduledTask> taskIter(iTaskList);
1.235 + taskIter.SetToFirst();
1.236 + TTsTime time;
1.237 + while((task = taskIter++) != NULL)
1.238 + {
1.239 + if (iDueTime.IsUtc())
1.240 + time.SetUtcTime(iDueTime.GetUtcTime() + iValidityPeriod);
1.241 + else
1.242 + time.SetLocalTime(iDueTime.GetLocalTime()+iValidityPeriod);
1.243 +
1.244 + task->OnDue(time);
1.245 + if (task->Info().iRepeat > 0)
1.246 + task->DecRepeat();
1.247 + if (task->Info().iRepeat == 0)
1.248 + RemoveTask(task);
1.249 + }
1.250 +
1.251 + LOGSTRING("CSchedule::NotifyTasks - end");
1.252 + }
1.253 +
1.254 +TInt CSchedule::GenerateTaskId()
1.255 + {
1.256 + LOGSTRING("CSchedule::GenerateTaskId - start");
1.257 +
1.258 + TInt id = iId;
1.259 + TScheduledTask* task = Task(id);
1.260 + while (task!=NULL)
1.261 + {
1.262 + if ((id-iId) > KMaxTasksPerSchedule)
1.263 + return KErrOverflow;
1.264 + id++;
1.265 + task = Task(id);
1.266 + }
1.267 + LOGSTRING("CSchedule::GenerateTaskId - end");
1.268 + return id;
1.269 + }
1.270 +
1.271 +TScheduledTask* CSchedule::Task(const TInt aTaskId)
1.272 + {
1.273 + TSglQueIter<TScheduledTask> tasks(iTaskList);
1.274 + tasks.SetToFirst();
1.275 + //
1.276 + TScheduledTask* task;
1.277 + while ((task=tasks++)!=NULL)
1.278 + {
1.279 + if (task->Info().iTaskId == aTaskId)
1.280 + return task;
1.281 + }
1.282 + return NULL;
1.283 + }
1.284 +
1.285 +void CSchedule::TasksL(CArrayFixFlat<TTaskInfo>& aTasks)
1.286 + {
1.287 + LOGSTRING("CSchedule::TasksL - start");
1.288 + TSglQueIter<TScheduledTask> taskIter(iTaskList);
1.289 + taskIter.SetToFirst();
1.290 + TScheduledTask* task;
1.291 + while ((task = taskIter++) != NULL)
1.292 + {
1.293 + aTasks.AppendL(task->Info());
1.294 + }
1.295 + LOGSTRING("CSchedule::TasksL - end");
1.296 + }
1.297 +
1.298 +//
1.299 +//Externalize/Internalize methods
1.300 +//
1.301 +void CSchedule::ExternalizeL(RWriteStream& aWriteStream) const
1.302 + {
1.303 + LOGSTRING("CSchedule::ExternalizeL - start");
1.304 +
1.305 + aWriteStream.WriteInt32L(iId);
1.306 + aWriteStream << *iName;
1.307 + aWriteStream.WriteInt32L(iPersists);
1.308 + aWriteStream.WriteInt32L(iEnabled);
1.309 +
1.310 + TInt count=0;
1.311 + // Count the number of schedule entries so that
1.312 + // we can write the count (in the stream) in advance
1.313 + // of the entries themselves.
1.314 + TSglQueIter<TScheduleEntry> iter(iEntryList);
1.315 + iter.SetToFirst();
1.316 +
1.317 + TScheduleEntry* entry;
1.318 + while((entry=iter++)!=NULL)
1.319 + count++;
1.320 + aWriteStream.WriteInt32L(count);
1.321 +
1.322 + // Write the entries
1.323 + iter.SetToFirst();
1.324 + while((entry=iter++)!=NULL)
1.325 + {
1.326 + entry->Info().ExternalizeL(aWriteStream);
1.327 + }
1.328 +
1.329 + //write conditions
1.330 + count = iConditions.Count();
1.331 + aWriteStream.WriteInt32L(count);
1.332 + for(TInt ii = 0; ii<count; ++ii)
1.333 + {
1.334 + aWriteStream.WriteInt32L(iConditions[ii].iCategory.iUid);
1.335 + aWriteStream.WriteUint32L(iConditions[ii].iKey);
1.336 + aWriteStream.WriteInt32L(iConditions[ii].iState);
1.337 + aWriteStream.WriteInt32L(iConditions[ii].iType);
1.338 + }
1.339 +
1.340 + //write security Info
1.341 + aWriteStream << iSecurityInfo;
1.342 +
1.343 + LOGSTRING("CSchedule::ExternalizeL - end");
1.344 + }
1.345 +
1.346 +void CSchedule::InternalizeL(RReadStream& aReadStream)
1.347 + {
1.348 + LOGSTRING("CSchedule::InternalizeL - start");
1.349 + iId = aReadStream.ReadInt32L();
1.350 + HBufC* name = HBufC::NewL(aReadStream, KMaxName);
1.351 + delete iName;
1.352 + iName = name;
1.353 + iPersists = aReadStream.ReadInt32L();
1.354 + iEnabled = aReadStream.ReadInt32L();
1.355 +
1.356 + //Make sure we remove the entries first!
1.357 + RemoveEntries();
1.358 +
1.359 + TInt entries = aReadStream.ReadInt32L();
1.360 + for (TInt i=0; i<entries;i++)
1.361 + {
1.362 + TScheduleEntryInfo2 info;
1.363 + info.InternalizeL(aReadStream);
1.364 + TScheduleEntry* entry = ScheduleEntryFactory::CreateL(info);
1.365 + iEntryList.AddLast(*entry);
1.366 + }
1.367 +
1.368 + // now read in conditions
1.369 + RemoveConditions();
1.370 + TInt conditions = aReadStream.ReadInt32L();
1.371 + for (TInt ii=0; ii<conditions;++ii)
1.372 + {
1.373 + TUid category;
1.374 + category.iUid = aReadStream.ReadInt32L();
1.375 + TUint key = aReadStream.ReadUint32L();
1.376 + TInt state = aReadStream.ReadInt32L();
1.377 + TTaskSchedulerCondition::TConditionType type
1.378 + = static_cast<TTaskSchedulerCondition::TConditionType>(aReadStream.ReadInt32L());
1.379 + TTaskSchedulerCondition condition(category, key, state, type);
1.380 + User::LeaveIfError(iConditions.Append(condition));
1.381 + }
1.382 +
1.383 + // read in security Info
1.384 + aReadStream >> iSecurityInfo;
1.385 +
1.386 + LOGSTRING("CSchedule::InternalizeL - end");
1.387 + }
1.388 +
1.389 +//
1.390 +//Entries methods
1.391 +//
1.392 +
1.393 +void CSchedule::EntriesL(CArrayFixFlat<TScheduleEntryInfo2>& aEntries)
1.394 + {
1.395 + LOGSTRING("CSchedule::EntriesL - start");
1.396 + TSglQueIter<TScheduleEntry> entryIter(iEntryList);
1.397 + entryIter.SetToFirst();
1.398 + TScheduleEntry* entry;
1.399 + while ((entry = entryIter++) != NULL)
1.400 + {
1.401 + aEntries.AppendL(entry->Info());
1.402 + }
1.403 + LOGSTRING("CSchedule::EntriesL - end");
1.404 + }
1.405 +
1.406 +void CSchedule::AddEntriesL(const CArrayFixFlat<TScheduleEntryInfo2>& aEntries)
1.407 + {
1.408 + LOGSTRING("CSchedule::AddEntriesL - start");
1.409 + TInt count = aEntries.Count();
1.410 + TScheduleEntryInfo2 entryInfo2;
1.411 + TTsTime ttsTime; //temporary needed due to gccxml compiler
1.412 + TDateTime dateTime;
1.413 +
1.414 + for (TInt i = 0;i<count;i++)
1.415 + {
1.416 + entryInfo2 = aEntries.At(i);
1.417 +
1.418 + // Zero out time to the nearest ms.
1.419 + if(entryInfo2.StartTime().IsUtc())
1.420 + {
1.421 + dateTime = entryInfo2.StartTime().GetUtcTime().DateTime();
1.422 + dateTime.SetMicroSecond(0);
1.423 + ttsTime.SetUtcTime(dateTime);
1.424 + entryInfo2.SetStartTime(ttsTime);
1.425 + }
1.426 + else
1.427 + {
1.428 + dateTime = entryInfo2.StartTime().GetLocalTime().DateTime();
1.429 + dateTime.SetMicroSecond(0);
1.430 + ttsTime.SetLocalTime(dateTime);
1.431 + entryInfo2.SetStartTime(ttsTime);
1.432 + }
1.433 +
1.434 + TScheduleEntry* entry = ScheduleEntryFactory::CreateL(entryInfo2);
1.435 + iEntryList.AddLast(*entry);
1.436 + }
1.437 +
1.438 + LOGSTRING("CSchedule::AddEntriesL - end");
1.439 + }
1.440 +
1.441 +void CSchedule::ReplaceEntriesL(const CArrayFixFlat<TScheduleEntryInfo2>& aEntries)
1.442 + {
1.443 + // remove the original entries
1.444 + RemoveEntries();
1.445 + AddEntriesL(aEntries);
1.446 + }
1.447 +
1.448 +void CSchedule::RemoveEntries()
1.449 + {
1.450 + LOGSTRING("CSchedule::RemoveEntries - start");
1.451 +
1.452 + TScheduleEntry* entry;
1.453 + TSglQueIter<TScheduleEntry> iter(iEntryList);
1.454 + iter.SetToFirst();
1.455 + while ((entry = iter++) != NULL)
1.456 + {
1.457 + iEntryList.Remove(*entry);
1.458 + delete entry;
1.459 + }
1.460 +
1.461 + LOGSTRING("CSchedule::RemoveEntries - end");
1.462 + }
1.463 +
1.464 +//Condition methods
1.465 +void CSchedule::AddConditionsL(const CArrayFixFlat<TTaskSchedulerCondition>& aConditions)
1.466 + {
1.467 + TInt count = aConditions.Count();
1.468 + for (TInt i = 0;i<count;++i)
1.469 + User::LeaveIfError(iConditions.Append(aConditions[i]));
1.470 + }
1.471 +
1.472 +void CSchedule::ReplaceConditionsL(const CArrayFixFlat<TTaskSchedulerCondition>& aConditions)
1.473 + {
1.474 + // remove the original conditions
1.475 + RemoveConditions();
1.476 + AddConditionsL(aConditions);
1.477 + }
1.478 +
1.479 +void CSchedule::ConditionsL(CArrayFixFlat<TTaskSchedulerCondition>& aConditions)
1.480 + {
1.481 + TInt count = iConditions.Count();
1.482 + for (TInt i = 0;i<count;++i)
1.483 + {
1.484 + aConditions.AppendL(iConditions[i]);
1.485 + }
1.486 + }
1.487 +
1.488 +void CSchedule::RemoveConditions()
1.489 + {
1.490 + iConditions.Reset();
1.491 + }
1.492 +
1.493 +const TTsTime& CSchedule::DefaultRunTimeL() const
1.494 + {
1.495 + TSglQueIter<TScheduleEntry> entryIter(iEntryList);
1.496 + entryIter.SetToFirst();
1.497 + TScheduleEntry* entry = entryIter;
1.498 + if (entry == NULL)
1.499 + User::Leave(KErrArgument);
1.500 + return entry->DueTime();
1.501 + }
1.502 +
1.503 +// This method is called when ever a new task is scheduled or a change to an
1.504 +// existing schedule is made. When one of the schedule entries in this schedule
1.505 +// has become due, this is called with aNotFirstTime = ETrue. All this does is
1.506 +// move the next due time into the next time frame.
1.507 +void CSchedule::CalculateDueTime(TBool aNotFirstTime)
1.508 + {
1.509 + // Sort the list of entries
1.510 + TSglQueIter<TScheduleEntry> iter(iEntryList);
1.511 + iter.SetToFirst();
1.512 + TScheduleEntry* entry;
1.513 + TTime currentTTime;
1.514 + TTsTime currentTTsTime;
1.515 + //make sure we reset iDueTime to max so that only the minimum is calculated.
1.516 + TTsTime maxTime(Time::MaxTTime(), ETrue);
1.517 + TTsTime dueTime;
1.518 + iDueTime = maxTime;
1.519 + while ((entry = iter++)!=NULL)
1.520 + {
1.521 + currentTTime.UniversalTime();
1.522 + currentTTsTime.SetUtcTime(currentTTime);
1.523 + // This works out when the schedule is next due based on the input time
1.524 + // and also updates the due time if it is home time based
1.525 + dueTime = entry->NextScheduledTime(currentTTsTime);
1.526 + if(aNotFirstTime && dueTime.GetUtcTime() <= currentTTime)
1.527 + {
1.528 + // We don't want this schedule to run straight away so seed the
1.529 + // next due initial time-frame by incrementing the validity
1.530 + currentTTime += entry->Info().ValidityPeriod();
1.531 + currentTTime += TTimeIntervalMicroSeconds32(1); // push into the next boundary
1.532 +
1.533 + if (dueTime.IsUtc())
1.534 + currentTTsTime.SetUtcTime(currentTTime);
1.535 + else
1.536 + currentTTsTime.SetLocalTime(currentTTime + dueTime.GetOffset());
1.537 +
1.538 + dueTime = entry->NextScheduledTime(currentTTsTime);
1.539 + }
1.540 + if(dueTime.GetUtcTime() < iDueTime.GetUtcTime()) //find earliest due time from all entries
1.541 + {
1.542 + iDueTime = dueTime;
1.543 + iValidityPeriod = entry->Info().ValidityPeriod();
1.544 + }
1.545 + }
1.546 + }
1.547 +
1.548 +// if aCalculateForConditions is true then entrycount corresponds
1.549 +// to number of conditions;
1.550 +void CSchedule::GetInfo(TScheduleInfo& aInfo, TBool aCalculateForConditions)
1.551 + {
1.552 + aInfo.iState.SetName(Name());
1.553 + aInfo.iState.SetDueTime(iDueTime);
1.554 + aInfo.iState.SetPersists(Persists());
1.555 + aInfo.iState.SetEnabled(Enabled());
1.556 + TInt taskCount = 0;
1.557 +
1.558 + TSglQueIter<TScheduledTask> taskIter(*Tasks());
1.559 + taskIter.SetToFirst();
1.560 + while (taskIter++ != NULL)
1.561 + {
1.562 + taskCount++;
1.563 + }
1.564 + aInfo.iTaskCount = taskCount;
1.565 + TInt entryCount = 0;
1.566 + if(!aCalculateForConditions)
1.567 + {
1.568 + TSglQueIter<TScheduleEntry> entryIter(iEntryList);
1.569 + entryIter.SetToFirst();
1.570 + while (entryIter++ != NULL)
1.571 + {
1.572 + entryCount++;
1.573 + }
1.574 + }
1.575 + else
1.576 + entryCount = iConditions.Count();
1.577 + aInfo.iEntryCount = entryCount;
1.578 + }
1.579 +
1.580 +const RArray<TTaskSchedulerCondition>& CSchedule::Conditions() const
1.581 + {
1.582 + return iConditions;
1.583 + }
1.584 +
1.585 +TBool CSchedule::IsAccessAllowed(const RMessagePtr2& aMessage) const
1.586 + {
1.587 + // Access allowed if message SID is the same as the schedule creator
1.588 + // or if client has WriteDeviceData
1.589 + return aMessage.SecureId()==iSecurityInfo.iSecureId
1.590 + || aMessage.HasCapability(ECapabilityWriteDeviceData)
1.591 + || PlatSec::ConfigSetting(PlatSec::EPlatSecEnforcement)==0; // Enforcement off
1.592 + }
1.593 +
1.594 +const TSecurityInfo& CSchedule::SecurityInfo() const
1.595 + {
1.596 + return iSecurityInfo;
1.597 + }
1.598 +
1.599 +TBool CSchedule::IsUpdatable()
1.600 + {
1.601 + if(HasTasks() && Enabled() )
1.602 + return ETrue;
1.603 + else
1.604 + return EFalse;
1.605 + }