static int
prepareActivity (ActivityObject *activity) {
ActivityPrepareMethod *prepare = activity->methods->prepare;
ActivityState oldState = activity->state;
if (!prepare) {
setActivityState(activity, ACT_PREPARED);
return 1;
}
setActivityState(activity, ACT_PREPARING);
if (!prepare(activity->data)) {
setActivityState(activity, oldState);
return 0;
}
if (activity->state == ACT_PREPARING) {
setActivityState(activity, ACT_PREPARED);
return 1;
}
if (activity->state == ACT_PREPARING_STOP) {
setActivityState(activity, ACT_STOPPED);
return 0;
}
logUnexpectedActivityState(activity, "preparing");
return 0;
}
void
startActivity (ActivityObject *activity) {
logActivityActionRequest(activity, "start");
while (1) {
switch (activity->state) {
case ACT_STOPPED:
if (prepareActivity(activity)) continue;
return;
case ACT_PREPARING_STOP:
setActivityState(activity, ACT_PREPARING);
continue;
case ACT_PREPARED:
if (scheduleActivity(activity)) continue;
return;
case ACT_SCHEDULED:
asyncResetAlarmIn(activity->startAlarm, 0);
return;
case ACT_STARTING_STOP:
setActivityState(activity, ACT_STARTING_RESTART);
continue;
case ACT_STOPPING:
setActivityState(activity, ACT_STOPPING_START);
continue;
case ACT_PREPARING:
case ACT_STARTING:
case ACT_STARTING_RESTART:
case ACT_STARTED:
case ACT_STOPPING_START:
return;
}
logUnexpectedActivityState(activity, "start");
break;
}
}
static int
scheduleActivity (ActivityObject *activity) {
if (asyncNewRelativeAlarm(&activity->startAlarm, 0, handleActivityStartAlarm, activity)) {
if (asyncResetAlarmEvery(activity->startAlarm, activity->methods->retryInterval)) {
setActivityState(activity, ACT_SCHEDULED);
return 1;
}
cancelActivityStartAlarm(activity);
}
return 0;
}
void Activities::Private::removeActivity(const QString &activity)
{
Q_ASSERT(!activity.isEmpty());
// Sanity checks
{
QWriteLocker lock(&activitiesLock);
if (!activities.contains(activity)) {
return;
}
// Is somebody trying to remove the last activity?
if (activities.size() == 1) {
return;
}
}
// If the activity is running, stash it
q->StopActivity(activity);
setActivityState(activity, Activities::Invalid);
bool currentActivityDeleted = false;
{
QWriteLocker lock(&activitiesLock);
// Removing the activity
activities.remove(activity);
// If the removed activity was the current one,
// set another activity as current
currentActivityDeleted = (currentActivity == activity);
}
activityNameConfig().deleteEntry(activity);
activityDescriptionConfig().deleteEntry(activity);
activityIconConfig().deleteEntry(activity);
if (currentActivityDeleted) {
ensureCurrentActivityIsRunning();
}
emit q->ActivityRemoved(activity);
QMetaObject::invokeMethod(q, "ActivityRemoved", Qt::QueuedConnection,
Q_ARG(QString, activity));
QMetaObject::invokeMethod(this, "configSync", Qt::QueuedConnection);
}
QString Activities::Private::addActivity(const QString &name)
{
QString activity;
if (name.isEmpty()) {
Q_ASSERT(!name.isEmpty());
return activity;
}
int activitiesCount = 0;
{
QWriteLocker lock(&activitiesLock);
// Ensuring a new Uuid. The loop should usually end after only
// one iteration
while (activity.isEmpty() || activities.contains(activity)) {
activity = QUuid::createUuid().toString().mid(1, 36);
}
// Saves the activity info to the config
activities[activity] = Invalid;
activitiesCount = activities.size();
}
setActivityState(activity, Running);
q->SetActivityName(activity, name);
emit q->ActivityAdded(activity);
scheduleConfigSync();
if (activitiesCount == 1) {
q->SetCurrentActivity(activity);
}
return activity;
}
void
stopActivity (ActivityObject *activity) {
logActivityActionRequest(activity, "stop");
while (1) {
switch (activity->state) {
case ACT_PREPARING:
setActivityState(activity, ACT_PREPARING_STOP);
continue;
case ACT_PREPARED:
setActivityState(activity, ACT_STOPPED);
continue;
case ACT_SCHEDULED:
cancelActivityStartAlarm(activity);
setActivityState(activity, ACT_PREPARED);
continue;
case ACT_STARTING:
case ACT_STARTING_RESTART:
setActivityState(activity, ACT_STARTING_STOP);
continue;
case ACT_STARTED: {
ActivityStopMethod *stop = activity->methods->stop;
if (stop) {
ActivityState newState;
setActivityState(activity, ACT_STOPPING);
stop(activity->data);
newState = activity->state;
setActivityState(activity, ACT_STOPPED);
if (newState == ACT_STOPPING_START) {
startActivity(activity);
} else if (newState != ACT_STOPPING) {
logUnexpectedActivityState(activity, "stopping");
}
} else {
setActivityState(activity, ACT_STOPPED);
}
return;
}
case ACT_STOPPING_START:
setActivityState(activity, ACT_STOPPING);
continue;
case ACT_PREPARING_STOP:
case ACT_STARTING_STOP:
case ACT_STOPPING:
case ACT_STOPPED:
return;
}
logUnexpectedActivityState(activity, "stop");
break;
}
}
