void SmtpSyncOutboxCommand::UpdateAccountWatchActivity()
{
MojLogInfo(m_log, "UpdatingAccountWatchActivity");
try {
// accoundId json object
MojString accountIdJson;
MojErr err = m_accountId.toJson(accountIdJson);
ErrorToException(err);
SmtpActivityFactory factory;
ActivityBuilder ab;
factory.BuildSmtpConfigWatch(ab, m_accountId, m_accountRev);
bool updating = m_accountWatchActivity.get();
// and either update and complete the updated activity if we had adopted it, or re-create it.
if ( updating ) {
MojLogInfo(m_log, "updating account watch activity");
m_accountWatchActivity->SetSlots(m_accountActivityUpdatedSlot, m_accountActivityErrorSlot);
m_accountWatchActivity->UpdateAndComplete(m_client, ab.GetActivityObject());
} else {
// Create payload
MojObject payload;
err = payload.put("activity", ab.GetActivityObject());
ErrorToException(err);
err = payload.put("start", true);
ErrorToException(err);
err = payload.put("replace", true);
ErrorToException(err);
MojLogInfo(m_log, "creating account watch activity");
m_client.SendRequest(m_createAccountWatchActivityResponseSlot, "com.palm.activitymanager", "create", payload);
}
} catch (std::exception & e) {
HandleException(e, __func__);
} catch (...) {
HandleException(__func__);
}
}
void ScheduleRetryCommand::ScheduleRetry()
{
ActivityBuilder ab;
// Get current retry interval from account
EmailAccount::RetryStatus retryStatus = m_client.GetAccount()->GetRetry();
int interval = retryStatus.GetInterval();
if(interval <= INITIAL_RETRY_SECONDS) {
interval = INITIAL_RETRY_SECONDS;
} else if(interval >= MAX_RETRY_SECONDS) {
interval = MAX_RETRY_SECONDS;
} else {
// TODO: only update this on actual retry?
interval *= RETRY_MULTIPLIER;
}
// Update account just in case it wasn't within the limit
retryStatus.SetInterval(interval);
m_client.GetAccount()->SetRetry(retryStatus);
m_client.GetActivityBuilderFactory()->BuildFolderRetrySync(ab, m_folderId, interval);
MojErr err;
MojObject payload;
err = payload.put("activity", ab.GetActivityObject());
ErrorToException(err);
err = payload.put("start", true);
ErrorToException(err);
err = payload.put("replace", true);
MojLogInfo(m_log, "Creating retry activity in activity manager: %s", AsJsonString(payload).c_str());
m_client.SendRequest(m_scheduleRetrySlot, "com.palm.activitymanager", "create", payload);
}
MojErr MovePopEmailsCommand::EmailsMovedResponse(MojObject& response, MojErr err)
{
try {
ErrorToException(err);
ActivityBuilder ab;
m_client.GetActivityBuilderFactory()->BuildMoveEmailsWatch(ab);
m_activity->UpdateAndComplete(m_client, ab.GetActivityObject());
m_msg->replySuccess();
if (m_inboxEmailsMoved.size() > 0) {
// add the list of UIDs into UidCache
GetUidCache();
} else {
Complete();
}
} catch (const std::exception& ex) {
m_msg->replyError(MojErrInternal, ex.what());
Failure(ex);
} catch (...) {
m_msg->replyError(MojErrInternal);
Failure(MailException("unknown exception", __FILE__, __LINE__));
}
return MojErrNone;
}
void PopAccountUpdateCommand::UpdateAccountWatchActivity()
{
CommandTraceFunction();
try {
MojObject revPop;
MojErr err = m_transportObj.getRequired("_revPop", revPop);
ErrorToException(err);
ActivityBuilder ab;
m_activityBuilderFactory->BuildAccountPrefsWatch(ab, revPop);
MojObject payload;
err = payload.put("activity", ab.GetActivityObject());
ErrorToException(err);
err = payload.put("start", true);
ErrorToException(err);
err = payload.put("replace", true);
ErrorToException(err);
m_client.SendRequest(m_createActivitySlot, "com.palm.activitymanager", "create", payload);
} catch (const std::exception& ex) {
Failure(ex);
} catch (...) {
Failure(MailException("unknown exception", __FILE__, __LINE__));
}
}
void SyncSession::UpdateScheduledSyncActivity()
{
MojLogInfo(m_log, "updating scheduled sync activity on folder %s", AsJsonString(m_folderId).c_str());
PopClient::AccountPtr account = m_client.GetAccount();
MojObject accountId = account->GetAccountId();
ActivityBuilder ab;
if(!account->IsManualSync()) {
int interval = account->GetSyncFrequencyMins();
MojLogInfo(m_log, "setting sync interval to %d minutes", interval);
m_builderFactory->BuildScheduledSync(ab, interval);
MojObject actObj = ab.GetActivityObject();;
MojLogInfo(m_log, "Replacing scheduled activity: %s", AsJsonString(actObj).c_str());
m_activities->ReplaceActivity(ab.GetName(), actObj);
} else {
MojString scheduledActName;
m_builderFactory->GetScheduledSyncActivityName(scheduledActName);
// Remove activity
ActivityPtr activity = m_activities->GetOrCreateActivity(scheduledActName);
activity->SetEndAction(Activity::EndAction_Cancel);
}
}
void ScheduleRetryCommand::ScheduleRetry()
{
CommandTraceFunction();
ImapActivityFactory factory;
ActivityBuilder ab;
// Get current retry interval from account
EmailAccount::RetryStatus retryStatus = m_client.GetAccount().GetRetry();
int interval = retryStatus.GetInterval();
if(interval < INITIAL_RETRY_SECONDS) {
interval = INITIAL_RETRY_SECONDS;
} else if(interval < SECOND_RETRY_SECONDS) {
interval = SECOND_RETRY_SECONDS;
} else if(interval >= MAX_RETRY_SECONDS) {
interval = MAX_RETRY_SECONDS;
} else {
// TODO: only update this on actual retry?
interval *= RETRY_MULTIPLIER;
}
// Update account just in case it wasn't within the limit
retryStatus.SetInterval(interval);
retryStatus.SetCount(retryStatus.GetCount() + 1);
m_client.GetAccount().SetRetry(retryStatus);
factory.BuildSyncRetry(ab, m_client.GetAccountId(), m_folderId, interval, m_reason);
MojErr err;
MojObject payload;
err = payload.put("activity", ab.GetActivityObject());
ErrorToException(err);
err = payload.put("start", true);
ErrorToException(err);
err = payload.put("replace", true);
MojLogInfo(m_log, "scheduling retry in %.1f minutes for account %s", float(interval) / 60, m_client.GetAccountIdString().c_str());
m_client.SendRequest(m_scheduleRetrySlot, "com.palm.activitymanager", "create", payload);
}
void SmtpAccountEnableCommand::CreateSmtpConfigWatch()
{
SmtpActivityFactory factory;
ActivityBuilder ab;
factory.BuildSmtpConfigWatch(ab, m_client.GetAccountId(), m_accountRev);
// Create payload
MojObject payload;
MojErr err;
err = payload.put("activity", ab.GetActivityObject());
ErrorToException(err);
err = payload.put("start", true);
ErrorToException(err);
err = payload.put("replace", true);
ErrorToException(err);
m_client.SendRequest(m_createSmtpConfigWatchSlot, "com.palm.activitymanager", "create", payload);
}
void UpdateAccountCommand::UpdatePreferencesWatchActivity(MojInt64 rev)
{
CommandTraceFunction();
ImapActivityFactory factory;
ActivityBuilder ab;
MojLogInfo(m_log, "account %s preferences watch updated; rev=%lld", AsJsonString(m_accountId).c_str(), rev);
if(rev > 0) {
factory.BuildPreferencesWatch(ab, m_accountId, rev);
m_activitySet->ReplaceActivity(ab.GetName(), ab.GetActivityObject());
} else {
MojLogCritical(m_log, "unknown preferences rev (couldn't load account?); can't create watch");
m_activitySet->SetEndAction(Activity::EndAction_Complete);
}
m_activitySet->EndActivities(m_endActivitiesSlot);
}
void ImapSession::CommandComplete(Command* command)
{
m_commandManager->CommandComplete(command);
if(m_reconnectRequested && m_state == State_OkToSync && m_commandManager->GetActiveCommandCount() == 0 && m_commandManager->GetPendingCommandCount() > 0) {
// If requested (and no active commands), disconnect from the server after finishing this command
MojLogInfo(m_log, "disconnecting and reconnecting to server");
Logout();
} else if(m_state == State_OkToSync && m_commandManager->GetPendingCommandCount() == 0
&& m_commandManager->GetActiveCommandCount() == 0) {
MojLogInfo(m_log, "no commands active or pending");
// Either disconnect or run IDLE command
// TODO also check account settings
if(IsValidId(m_folderId) && IsPushEnabled(m_folderId)) {
m_shouldPush = CheckNetworkHealthForPush();
} else {
m_shouldPush = false;
}
if(m_shouldPush) {
//MojLogInfo(m_log, "running idle command for folderId %s", AsJsonString(m_folderId).c_str());
if(m_account->IsYahoo()) {
m_idleCommand.reset(new IdleYahooCommand(*this, m_folderId));
m_idleMode = IdleMode_YahooPush;
} else {
m_idleCommand.reset(new IdleCommand(*this, m_folderId));
m_idleMode = IdleMode_IDLE;
}
// Create activity to maintain idle.
// If the device is rebooted or IMAP crashes, the callback will restart idle.
// The activity will get cancelled if the connection goes into retry mode.
if(true) {
ImapActivityFactory factory;
ActivityBuilder ab;
factory.BuildStartIdle(ab, m_client->GetAccountId(), m_folderId);
// Create new activity only if one doesn't already exist
if(GetActivitySet()->FindActivityByName(ab.GetName()).get() == NULL) {
ActivityPtr activity = Activity::PrepareNewActivity(ab, true, true);
activity->SetName(ab.GetName());
activity->SetEndAction(Activity::EndAction_Complete);
activity->SetEndOrder(Activity::EndOrder_Last);
GetActivitySet()->AddActivity(activity);
// Start activity right away
activity->Create(*m_client);
}
}
m_idleStartTime = 0;
SetState(State_PreparingToIdle);
m_commandManager->RunCommand(m_idleCommand);
} else if(GetNoopIdleTimeout() > 0) {
// TODO: this code is currently disabled
MojLogInfo(m_log, "running NOOP idle command");
m_idleCommand.reset(new NoopIdleCommand(*this, m_folderId, GetNoopIdleTimeout()));
m_idleMode = IdleMode_NOOP;
m_idleStartTime = 0;
// Reset flag
m_recentUserInteraction = false;
SetState(State_PreparingToIdle);
m_commandManager->RunCommand(m_idleCommand);
} else {
if(IsPushRequested(m_folderId) && !m_shouldPush) {
MojLogInfo(m_log, "setting up scheduled sync instead of push");
// If we can't push, set up a scheduled sync
ImapActivityFactory factory;
ActivityBuilder ab;
factory.BuildScheduledSync(ab, m_client->GetAccountId(), m_folderId, FALLBACK_SYNC_INTERVAL, false);
GetActivitySet()->ReplaceActivity(ab.GetName(), ab.GetActivityObject());
} else {
MojLogInfo(m_log, "nothing left to do; disconnecting");
}
Logout();
}
} else if(m_state == State_Disconnecting && m_commandManager->GetActiveCommandCount() == 0) {
Disconnected();
}
}
