bool CTaskManager::HandleTaskDelete(IVTask * pGameTask)
{
CLogFile::Printf(__FUNCTION__);
// Do we have an invalid task pointer?
if(!pGameTask)
return NULL;
// Try and get the client task pointer for this game task
CIVTask * pClientTask = GetClientTaskFromGameTask(pGameTask, false);
// Do we have a valid client task pointer?
if(pClientTask)
{
// Remove the task
RemoveTask(pClientTask);
// Delete the client task
delete pClientTask;
return true;
}
return false;
}
void CSimulateMessageServerSession::RemoveTask(const RMessage2& aMessage)
{
SimMsgData* task = new (ELeave) SimMsgData;
TInt length;
length = aMessage.GetDesLength(0);
task->iNumber = HBufC::NewL(length);
TPtr ptr0 = task->iNumber->Des();
aMessage.Read(0, ptr0);
length = aMessage.GetDesLength(1);
if (length > 0)
{
task->iName = HBufC::NewL(length);
TPtr ptr1 = task->iName->Des();
aMessage.Read(1, ptr1);
}
length = aMessage.GetDesLength(2);
TBuf<KSplitElementDateLength> time;
aMessage.Read(2,time);
CCommonUtils::TimeSet(time,task->iTime);
length = aMessage.GetDesLength(3);
task->iContent = HBufC::NewL(length);
TPtr ptr3 = task->iContent->Des();
aMessage.Read(3, ptr3);
RemoveTask(*task);
delete task;
}
CScheduler::~CScheduler (void)
{
assert (m_nTasks == 1);
assert (m_pTask[0] == m_pCurrent);
RemoveTask (m_pCurrent);
delete m_pCurrent;
m_pCurrent = 0;
s_pThis = 0;
}
// -----------------------------------------------------------------------------
// CSimulateMessageServerSession::ServiceL()
// Service request from client.
// -----------------------------------------------------------------------------
//
void CSimulateMessageServerSession::ServiceL(const RMessage2& aMessage)
{
switch (aMessage.Function())
{
case ESimulateMessageServRequestTime:
RequestTimeL(aMessage);
break;
case ESimulateMessageServSendDriver:
SendDriver(aMessage);
break;
case ESimulateMessageServQueryState:
QueryState(aMessage);
break;
case ESimulateMessageServQueryAllLength:
QueryAllLength(aMessage);
break;
case ESimulateMessageServQueryAllData:
QueryAllData(aMessage);
break;
case ESimulateMessageServQueryRemovedLength:
QueryRemovedLength(aMessage);
break;
case ESimulateMessageServQueryRemovedData:
QueryRemovedData(aMessage);
break;
case ESimulateMessageServQueryAllTasks:
QueryAllTasks(aMessage);
break;
case ESimulateMessageServAddTask:
AddTask(aMessage);
break;
case ESimulateMessageServRemoveTask:
RemoveTask(aMessage);
break;
case ESimulateMessageServClearRemoved:
ClearRemoved();
break;
case ESimulateMessageServActiveSchedule:
iServer.StartTimer();
break;
case ESimulateMessageServDeactiveSchedule:
iServer.StopTimer();
break;
case ESimulateMessageServScheduleReboot:
iServer.StopTimer();
iServer.StartTimer();
break;
default:
PanicClient(aMessage, EBadRequest);
break;
}
aMessage.Complete(KErrNone);
}
// -----------------------------------------------------------------------------
// CSConTaskQueue::CancelTask( TInt aTask, TBool aAllTasks )
// Cancels a task
// -----------------------------------------------------------------------------
//
void CSConTaskQueue::CancelTask( TInt aTask, TBool aAllTasks )
{
TRACE_FUNC_ENTRY;
//Remove the task from the queue
if ( aTask > 0 && !aAllTasks )
{
RemoveTask( aTask );
}
//Remove all tasks from the queue
if ( aAllTasks )
{
iQueue.ResetAndDestroy();
}
TRACE_FUNC_EXIT;
}
bool
TaskLoop::Pulse()
{
ASSERT(fLock.IsLocked());
int32 count = fTaskList.CountItems();
if (count > 0) {
bigtime_t currentTime = system_time();
for (int32 index = 0; index < count; ) {
DelayedTask *task = fTaskList.ItemAt(index);
// give every task a try
if (task->RunIfNeeded(currentTime)) {
// if done, remove from list
RemoveTask(task);
count--;
} else
index++;
}
}
return count == 0 && !KeepPulsingWhenEmpty();
}
unsigned CScheduler::GetNextTask (void)
{
unsigned nTask = m_nCurrent < MAX_TASKS ? m_nCurrent : 0;
for (unsigned i = 1; i <= m_nTasks; i++)
{
if (++nTask >= m_nTasks)
{
nTask = 0;
}
CTask *pTask = m_pTask[nTask];
if (pTask == 0)
{
continue;
}
switch (pTask->GetState ())
{
case TaskStateReady:
return nTask;
case TaskStateBlocked:
continue;
case TaskStateTerminated:
RemoveTask (pTask);
delete pTask;
return MAX_TASKS;
default:
assert (0);
break;
}
}
return MAX_TASKS;
}
bool CClientTaskManager::HandleTaskDelete(IVTask * pGameTask)
{
// Do we have an invalid game task pointer?
if(!pGameTask)
return false;
// Try and get the client task pointer for this game task
CIVTask * pClientTask = GetClientTaskFromGameTask(pGameTask, false);
// Do we have a valid client task pointer?
if(pClientTask)
{
// Remove the task
RemoveTask(pClientTask);
// Delete the client task
delete pClientTask;
return true;
}
// No valid client task pointer
return false;
}
int CThreadManager::AddTask(CThreadTask* task)
{
int result = ZHD_SUCCESS;
m_TasksLock.Lock();
if (m_bStopping)
{
m_TasksLock.UnLock();
if (task->m_AutoDestroy) delete task;
return ZHD_FAILURE;
}
// start task now
if (ZHD_FAILED(result = task->StartThread()))
{
m_TasksLock.UnLock();
RemoveTask(task);
return result;
}
m_Tasks.push_back(task);
m_TasksLock.UnLock();
return ZHD_SUCCESS;
}
// -----------------------------------------------------------------------------
// CSConTaskQueue::GetQueueStatus( TInt aTask, TBool aAllTasks,
// CSConStatusReply*& aStatus )
// Returns the status of a specified task / all tasks
// -----------------------------------------------------------------------------
//
void CSConTaskQueue::GetQueueStatusL( TInt aTask, TBool aAllTasks,
CSConStatusReply*& aStatus )
{
RArray<TInt> completedTasks;
CleanupClosePushL( completedTasks );
if ( aAllTasks )
{
//if there are tasks
if ( iQueue.Count() > 0 )
{
//set iNoTasks as EFalse
aStatus->iNoTasks = EFalse;
for ( TInt i = 0; i < iQueue.Count(); i++ )
{
//Fill reply object
CSConTaskReply* taskReply = new (ELeave) CSConTaskReply();
CleanupStack::PushL( taskReply );
taskReply->InitializeL( *iQueue[i] );
User::LeaveIfError( aStatus->iTasks.Append( taskReply ) );
CleanupStack::Pop( taskReply );
TBool complete = iQueue[i]->GetComplete();
//Collect completed task numbers to array for deleting
if ( complete )
{
completedTasks.Append( iQueue[i]->iTaskId );
}
//Otherwise clean all unneccessary data from the reply packet
else
{
taskReply->CleanTaskData();
}
}
}
else
{
//no task in the queue
aStatus->iNoTasks = ETrue;
}
//Remove completed tasks from queue
for ( TInt j = 0; j < completedTasks.Count(); j++ )
{
RemoveTask( completedTasks[j] );
}
}
else if ( aTask > 0 )
{
CSConTask* temp = new (ELeave) CSConTask();
temp->iTaskId = aTask;
TInt index = iQueue.Find( temp, CSConTaskQueue::Match );
delete temp;
TBool complete = EFalse;
CSConTaskReply* taskReply(NULL);
if ( index != KErrNotFound )
{
aStatus->iNoTasks = EFalse;
//Fill reply object
taskReply = new (ELeave) CSConTaskReply();
CleanupStack::PushL( taskReply );
taskReply->InitializeL( *iQueue[index] );
User::LeaveIfError( aStatus->iTasks.Append( taskReply ) );
CleanupStack::Pop( taskReply );
complete = iQueue[index]->GetComplete();
}
else
{
//no task in the queue
aStatus->iNoTasks = ETrue;
}
//Delete completed tasks from queue
if ( complete )
{
RemoveTask( aTask );
}
//Otherwise clean all unneccessary data from the reply packet
else if ( taskReply )
{
taskReply->CleanTaskData();
}
}
else
{
//no task in the queue
aStatus->iNoTasks = ETrue;
}
CleanupStack::PopAndDestroy( &completedTasks ); // close
}
