diff options
Diffstat (limited to 'src/async/imap/MCIMAPAsyncSession.cpp')
| -rwxr-xr-x | src/async/imap/MCIMAPAsyncSession.cpp | 848 |
1 files changed, 848 insertions, 0 deletions
diff --git a/src/async/imap/MCIMAPAsyncSession.cpp b/src/async/imap/MCIMAPAsyncSession.cpp new file mode 100755 index 00000000..f3a55a5e --- /dev/null +++ b/src/async/imap/MCIMAPAsyncSession.cpp @@ -0,0 +1,848 @@ +// +// MCIMAPAsyncSession.cc +// mailcore2 +// +// Created by DINH Viêt Hoà on 1/17/13. +// Copyright (c) 2013 MailCore. All rights reserved. +// + +#include "MCIMAPAsyncSession.h" + +#include "MCIMAPAsyncConnection.h" +#include "MCIMAPNamespace.h" +#include "MCOperationQueueCallback.h" +#include "MCConnectionLogger.h" +#include "MCIMAPSession.h" +#include "MCIMAPIdentity.h" +#include "MCIMAPMultiDisconnectOperation.h" + +#include "MCIMAPFolderInfoOperation.h" +#include "MCIMAPFolderStatusOperation.h" +#include "MCIMAPFetchFoldersOperation.h" +#include "MCIMAPRenameFolderOperation.h" +#include "MCIMAPDeleteFolderOperation.h" +#include "MCIMAPCreateFolderOperation.h" +#include "MCIMAPSubscribeFolderOperation.h" +#include "MCIMAPExpungeOperation.h" +#include "MCIMAPAppendMessageOperation.h" +#include "MCIMAPCopyMessagesOperation.h" +#include "MCIMAPFetchMessagesOperation.h" +#include "MCIMAPFetchContentOperation.h" +#include "MCIMAPFetchParsedContentOperation.h" +#include "MCIMAPStoreFlagsOperation.h" +#include "MCIMAPStoreLabelsOperation.h" +#include "MCIMAPSearchOperation.h" +#include "MCIMAPConnectOperation.h" +#include "MCIMAPCheckAccountOperation.h" +#include "MCIMAPFetchNamespaceOperation.h" +#include "MCIMAPIdleOperation.h" +#include "MCIMAPIdentityOperation.h" +#include "MCIMAPCapabilityOperation.h" +#include "MCIMAPQuotaOperation.h" +#include "MCIMAPDisconnectOperation.h" +#include "MCIMAPNoopOperation.h" +#include "MCIMAPMessageRenderingOperation.h" + +#define DEFAULT_MAX_CONNECTIONS 3 + +using namespace mailcore; + +IMAPAsyncSession::IMAPAsyncSession() +{ + mSessions = new Array(); + mMaximumConnections = DEFAULT_MAX_CONNECTIONS; + mAllowsFolderConcurrentAccessEnabled = true; + + mHostname = NULL; + mPort = 0; + mUsername = NULL; + mPassword = NULL; + mOAuth2Token = NULL; + mAuthType = AuthTypeSASLNone; + mConnectionType = ConnectionTypeClear; + mCheckCertificateEnabled = true; + mVoIPEnabled = true; + mDefaultNamespace = NULL; + mTimeout = 30.; + mConnectionLogger = NULL; + mAutomaticConfigurationDone = false; + mServerIdentity = new IMAPIdentity(); + mClientIdentity = new IMAPIdentity(); + mOperationQueueCallback = NULL; +#if __APPLE__ + mDispatchQueue = dispatch_get_main_queue(); +#endif + mGmailUserDisplayName = NULL; +} + +IMAPAsyncSession::~IMAPAsyncSession() +{ +#if __APPLE__ + if (mDispatchQueue != NULL) { + dispatch_release(mDispatchQueue); + } +#endif + MC_SAFE_RELEASE(mGmailUserDisplayName); + MC_SAFE_RELEASE(mServerIdentity); + MC_SAFE_RELEASE(mClientIdentity); + MC_SAFE_RELEASE(mSessions); + MC_SAFE_RELEASE(mHostname); + MC_SAFE_RELEASE(mUsername); + MC_SAFE_RELEASE(mPassword); + MC_SAFE_RELEASE(mOAuth2Token); + MC_SAFE_RELEASE(mDefaultNamespace); +} + +void IMAPAsyncSession::setHostname(String * hostname) +{ + MC_SAFE_REPLACE_COPY(String, mHostname, hostname); +} + +String * IMAPAsyncSession::hostname() +{ + return mHostname; +} + +void IMAPAsyncSession::setPort(unsigned int port) +{ + mPort = port; +} + +unsigned int IMAPAsyncSession::port() +{ + return mPort; +} + +void IMAPAsyncSession::setUsername(String * username) +{ + MC_SAFE_REPLACE_COPY(String, mUsername, username); +} + +String * IMAPAsyncSession::username() +{ + return mUsername; +} + +void IMAPAsyncSession::setPassword(String * password) +{ + MC_SAFE_REPLACE_COPY(String, mPassword, password); +} + +String * IMAPAsyncSession::password() +{ + return mPassword; +} + +void IMAPAsyncSession::setOAuth2Token(String * token) +{ + MC_SAFE_REPLACE_COPY(String, mOAuth2Token, token); +} + +String * IMAPAsyncSession::OAuth2Token() +{ + return mOAuth2Token; +} + +void IMAPAsyncSession::setAuthType(AuthType authType) +{ + mAuthType = authType; +} + +AuthType IMAPAsyncSession::authType() +{ + return mAuthType; +} + +void IMAPAsyncSession::setConnectionType(ConnectionType connectionType) +{ + mConnectionType = connectionType; +} + +ConnectionType IMAPAsyncSession::connectionType() +{ + return mConnectionType; +} + +void IMAPAsyncSession::setTimeout(time_t timeout) +{ + mTimeout = timeout; +} + +time_t IMAPAsyncSession::timeout() +{ + return mTimeout; +} + +void IMAPAsyncSession::setCheckCertificateEnabled(bool enabled) +{ + mCheckCertificateEnabled = enabled; +} + +bool IMAPAsyncSession::isCheckCertificateEnabled() +{ + return mCheckCertificateEnabled; +} + +void IMAPAsyncSession::setVoIPEnabled(bool enabled) +{ + mVoIPEnabled = enabled; +} + +bool IMAPAsyncSession::isVoIPEnabled() +{ + return mVoIPEnabled; +} + +IMAPNamespace * IMAPAsyncSession::defaultNamespace() +{ + return mDefaultNamespace; +} + +void IMAPAsyncSession::setDefaultNamespace(IMAPNamespace * ns) +{ + MC_SAFE_REPLACE_RETAIN(IMAPNamespace, mDefaultNamespace, ns); +} + +void IMAPAsyncSession::setAllowsFolderConcurrentAccessEnabled(bool enabled) +{ + mAllowsFolderConcurrentAccessEnabled = enabled; +} + +bool IMAPAsyncSession::allowsFolderConcurrentAccessEnabled() +{ + return mAllowsFolderConcurrentAccessEnabled; +} + +void IMAPAsyncSession::setMaximumConnections(unsigned int maxConnections) +{ + mMaximumConnections = maxConnections; +} + +unsigned int IMAPAsyncSession::maximumConnections() +{ + return mMaximumConnections; +} + +IMAPIdentity * IMAPAsyncSession::serverIdentity() +{ + return mServerIdentity; +} + +IMAPIdentity * IMAPAsyncSession::clientIdentity() +{ + return mClientIdentity; +} + +String * IMAPAsyncSession::gmailUserDisplayName() +{ + return mGmailUserDisplayName; +} + +IMAPAsyncConnection * IMAPAsyncSession::session() +{ + IMAPAsyncConnection * session = new IMAPAsyncConnection(); + session->setConnectionLogger(mConnectionLogger); + session->setOwner(this); + session->autorelease(); + + session->setHostname(mHostname); + session->setPort(mPort); + session->setUsername(mUsername); + session->setPassword(mPassword); + session->setOAuth2Token(mOAuth2Token); + session->setAuthType(mAuthType); + session->setConnectionType(mConnectionType); + session->setTimeout(mTimeout); + session->setCheckCertificateEnabled(mCheckCertificateEnabled); + session->setVoIPEnabled(mVoIPEnabled); + session->setDefaultNamespace(mDefaultNamespace); + session->setClientIdentity(mClientIdentity); +#if __APPLE__ + session->setDispatchQueue(mDispatchQueue); +#endif +#if 0 // should be implemented properly + if (mAutomaticConfigurationDone) { + session->setAutomaticConfigurationEnabled(false); + } +#endif + + return session; +} + +IMAPAsyncConnection * IMAPAsyncSession::sessionForFolder(String * folder, bool urgent) +{ + if (folder == NULL) { + return availableSession(); + } + else { + IMAPAsyncConnection * s = NULL; + if (urgent && mAllowsFolderConcurrentAccessEnabled) { + s = availableSession(); + if (s->operationsCount() == 0) { + s->setLastFolder(folder); + return s; + } + } + + s = matchingSessionForFolder(folder); + s->setLastFolder(folder); + return s; + } +} + +IMAPAsyncConnection * IMAPAsyncSession::availableSession() +{ + if (mMaximumConnections == 0) { + for(unsigned int i = 0 ; i < mSessions->count() ; i ++) { + IMAPAsyncConnection * s = (IMAPAsyncConnection *) mSessions->objectAtIndex(i); + if (s->operationsCount() == 0) + return s; + } + IMAPAsyncConnection * chosenSession = session(); + mSessions->addObject(chosenSession); + return chosenSession; + } + else { + IMAPAsyncConnection * chosenSession = NULL; + unsigned int minOperationsCount = 0; + for(unsigned int i = 0 ; i < mSessions->count() ; i ++) { + IMAPAsyncConnection * s = (IMAPAsyncConnection *) mSessions->objectAtIndex(i); + if (chosenSession == NULL) { + chosenSession = s; + minOperationsCount = s->operationsCount(); + } + else if (s->operationsCount() < minOperationsCount) { + chosenSession = s; + minOperationsCount = s->operationsCount(); + } + } + if (mSessions->count() < mMaximumConnections) { + if ((chosenSession != NULL) && (minOperationsCount == 0)) { + return chosenSession; + } + chosenSession = session(); + mSessions->addObject(chosenSession); + return chosenSession; + } + else { + return chosenSession; + } + } +} + +IMAPAsyncConnection * IMAPAsyncSession::matchingSessionForFolder(String * folder) +{ + for(unsigned int i = 0 ; i < mSessions->count() ; i ++) { + IMAPAsyncConnection * currentSession = (IMAPAsyncConnection *) mSessions->objectAtIndex(i); + if (currentSession->lastFolder() != NULL) { + if (currentSession->lastFolder()->isEqual(folder)) { + return currentSession; + } + } + else { + return currentSession; + } + } + return availableSession(); +} + +IMAPFolderInfoOperation * IMAPAsyncSession::folderInfoOperation(String * folder) +{ + IMAPFolderInfoOperation * op = new IMAPFolderInfoOperation(); + op->setMainSession(this); + op->setFolder(folder); + op->autorelease(); + return op; +} + +IMAPFolderStatusOperation * IMAPAsyncSession::folderStatusOperation(String * folder) +{ + IMAPFolderStatusOperation * op = new IMAPFolderStatusOperation(); + op->setMainSession(this); + op->setFolder(folder); + op->autorelease(); + return op; +} + +IMAPFetchFoldersOperation * IMAPAsyncSession::fetchSubscribedFoldersOperation() +{ + IMAPFetchFoldersOperation * op = new IMAPFetchFoldersOperation(); + op->setMainSession(this); + op->setFetchSubscribedEnabled(true); + op->autorelease(); + return op; +} + +IMAPFetchFoldersOperation * IMAPAsyncSession::fetchAllFoldersOperation() +{ + IMAPFetchFoldersOperation * op = new IMAPFetchFoldersOperation(); + op->setMainSession(this); + op->autorelease(); + return op; +} + +IMAPOperation * IMAPAsyncSession::renameFolderOperation(String * folder, String * otherName) +{ + IMAPRenameFolderOperation * op = new IMAPRenameFolderOperation(); + op->setMainSession(this); + op->setFolder(folder); + op->setOtherName(otherName); + op->autorelease(); + return op; +} + +IMAPOperation * IMAPAsyncSession::deleteFolderOperation(String * folder) +{ + IMAPDeleteFolderOperation * op = new IMAPDeleteFolderOperation(); + op->setMainSession(this); + op->setFolder(folder); + op->autorelease(); + return op; +} + +IMAPOperation * IMAPAsyncSession::createFolderOperation(String * folder) +{ + IMAPCreateFolderOperation * op = new IMAPCreateFolderOperation(); + op->setMainSession(this); + op->setFolder(folder); + op->autorelease(); + return op; +} + +IMAPOperation * IMAPAsyncSession::subscribeFolderOperation(String * folder) +{ + IMAPSubscribeFolderOperation * op = new IMAPSubscribeFolderOperation(); + op->setMainSession(this); + op->setFolder(folder); + op->autorelease(); + return op; +} + +IMAPOperation * IMAPAsyncSession::unsubscribeFolderOperation(String * folder) +{ + IMAPSubscribeFolderOperation * op = new IMAPSubscribeFolderOperation(); + op->setMainSession(this); + op->setUnsubscribeEnabled(true); + op->setFolder(folder); + op->autorelease(); + return op; +} + +IMAPAppendMessageOperation * IMAPAsyncSession::appendMessageOperation(String * folder, Data * messageData, MessageFlag flags, Array * customFlags) +{ + IMAPAppendMessageOperation * op = new IMAPAppendMessageOperation(); + op->setMainSession(this); + op->setFolder(folder); + op->setMessageData(messageData); + op->setFlags(flags); + op->setCustomFlags(customFlags); + op->autorelease(); + return op; +} + +IMAPCopyMessagesOperation * IMAPAsyncSession::copyMessagesOperation(String * folder, IndexSet * uids, String * destFolder) +{ + IMAPCopyMessagesOperation * op = new IMAPCopyMessagesOperation(); + op->setMainSession(this); + op->setFolder(folder); + op->setUids(uids); + op->setDestFolder(destFolder); + op->autorelease(); + return op; +} + +IMAPOperation * IMAPAsyncSession::expungeOperation(String * folder) +{ + IMAPExpungeOperation * op = new IMAPExpungeOperation(); + op->setMainSession(this); + op->setFolder(folder); + op->autorelease(); + return op; +} + +IMAPFetchMessagesOperation * IMAPAsyncSession::fetchMessagesByUIDOperation(String * folder, IMAPMessagesRequestKind requestKind, + IndexSet * uids) +{ + IMAPFetchMessagesOperation * op = new IMAPFetchMessagesOperation(); + op->setMainSession(this); + op->setFolder(folder); + op->setKind(requestKind); + op->setFetchByUidEnabled(true); + op->setIndexes(uids); + op->autorelease(); + return op; +} + +IMAPFetchMessagesOperation * IMAPAsyncSession::fetchMessagesByNumberOperation(String * folder, IMAPMessagesRequestKind requestKind, + IndexSet * numbers) +{ + IMAPFetchMessagesOperation * op = new IMAPFetchMessagesOperation(); + op->setMainSession(this); + op->setFolder(folder); + op->setKind(requestKind); + op->setIndexes(numbers); + op->autorelease(); + return op; +} + +IMAPFetchMessagesOperation * IMAPAsyncSession::syncMessagesByUID(String * folder, IMAPMessagesRequestKind requestKind, + IndexSet * uids, uint64_t modSeq) +{ + IMAPFetchMessagesOperation * op = new IMAPFetchMessagesOperation(); + op->setMainSession(this); + op->setFolder(folder); + op->setKind(requestKind); + op->setFetchByUidEnabled(true); + op->setIndexes(uids); + op->setModSequenceValue(modSeq); + op->autorelease(); + return op; +} + +IMAPFetchContentOperation * IMAPAsyncSession::fetchMessageByUIDOperation(String * folder, uint32_t uid, bool urgent) +{ + IMAPFetchContentOperation * op = new IMAPFetchContentOperation(); + op->setMainSession(this); + op->setFolder(folder); + op->setUid(uid); + op->setUrgent(urgent); + op->autorelease(); + return op; +} + +IMAPFetchContentOperation * IMAPAsyncSession::fetchMessageAttachmentByUIDOperation(String * folder, uint32_t uid, String * partID, + Encoding encoding, bool urgent) +{ + IMAPFetchContentOperation * op = new IMAPFetchContentOperation(); + op->setMainSession(this); + op->setFolder(folder); + op->setUid(uid); + op->setPartID(partID); + op->setEncoding(encoding); + op->setUrgent(urgent); + op->autorelease(); + return op; +} + +IMAPFetchContentOperation * IMAPAsyncSession::fetchMessageByNumberOperation(String * folder, uint32_t number, bool urgent) +{ + IMAPFetchContentOperation * op = new IMAPFetchContentOperation(); + op->setMainSession(this); + op->setFolder(folder); + op->setNumber(number); + op->setUrgent(urgent); + op->autorelease(); + return op; +} + +IMAPFetchContentOperation * IMAPAsyncSession::fetchMessageAttachmentByNumberOperation(String * folder, uint32_t number, String * partID, + Encoding encoding, bool urgent) +{ + IMAPFetchContentOperation * op = new IMAPFetchContentOperation(); + op->setMainSession(this); + op->setFolder(folder); + op->setNumber(number); + op->setPartID(partID); + op->setEncoding(encoding); + op->setUrgent(urgent); + op->autorelease(); + return op; +} + +IMAPFetchParsedContentOperation * IMAPAsyncSession::fetchParsedMessageByUIDOperation(String * folder, uint32_t uid, bool urgent) +{ + IMAPFetchParsedContentOperation * op = new IMAPFetchParsedContentOperation(); + op->setMainSession(this); + op->setFolder(folder); + op->setUid(uid); + op->setUrgent(urgent); + op->autorelease(); + return op; +} + +IMAPFetchParsedContentOperation * IMAPAsyncSession::fetchParsedMessageByNumberOperation(String * folder, uint32_t number, bool urgent) +{ + IMAPFetchParsedContentOperation * op = new IMAPFetchParsedContentOperation(); + op->setMainSession(this); + op->setFolder(folder); + op->setNumber(number); + op->setUrgent(urgent); + op->autorelease(); + return op; +} + +IMAPOperation * IMAPAsyncSession::storeFlagsByUIDOperation(String * folder, IndexSet * uids, IMAPStoreFlagsRequestKind kind, MessageFlag flags, Array * customFlags) +{ + IMAPStoreFlagsOperation * op = new IMAPStoreFlagsOperation(); + op->setMainSession(this); + op->setFolder(folder); + op->setUids(uids); + op->setKind(kind); + op->setFlags(flags); + op->setCustomFlags(customFlags); + op->autorelease(); + return op; +} + +IMAPOperation * IMAPAsyncSession::storeFlagsByNumberOperation(String * folder, IndexSet * numbers, IMAPStoreFlagsRequestKind kind, MessageFlag flags, Array * customFlags) +{ + IMAPStoreFlagsOperation * op = new IMAPStoreFlagsOperation(); + op->setMainSession(this); + op->setFolder(folder); + op->setNumbers(numbers); + op->setKind(kind); + op->setFlags(flags); + op->setCustomFlags(customFlags); + op->autorelease(); + return op; +} + +IMAPOperation * IMAPAsyncSession::storeLabelsByUIDOperation(String * folder, IndexSet * uids, IMAPStoreFlagsRequestKind kind, Array * labels) +{ + IMAPStoreLabelsOperation * op = new IMAPStoreLabelsOperation(); + op->setMainSession(this); + op->setFolder(folder); + op->setUids(uids); + op->setKind(kind); + op->setLabels(labels); + op->autorelease(); + return op; +} + +IMAPOperation * IMAPAsyncSession::storeLabelsByNumberOperation(String * folder, IndexSet * numbers, IMAPStoreFlagsRequestKind kind, Array * labels) +{ + IMAPStoreLabelsOperation * op = new IMAPStoreLabelsOperation(); + op->setMainSession(this); + op->setFolder(folder); + op->setNumbers(numbers); + op->setKind(kind); + op->setLabels(labels); + op->autorelease(); + return op; +} + +IMAPSearchOperation * IMAPAsyncSession::searchOperation(String * folder, IMAPSearchKind kind, String * searchString) +{ + IMAPSearchOperation * op = new IMAPSearchOperation(); + op->setMainSession(this); + op->setFolder(folder); + op->setSearchKind(kind); + op->setSearchString(searchString); + op->autorelease(); + return op; +} + +IMAPSearchOperation * IMAPAsyncSession::searchOperation(String * folder, IMAPSearchExpression * expression) +{ + IMAPSearchOperation * op = new IMAPSearchOperation(); + op->setMainSession(this); + op->setFolder(folder); + op->setSearchExpression(expression); + op->autorelease(); + return op; +} + +IMAPIdleOperation * IMAPAsyncSession::idleOperation(String * folder, uint32_t lastKnownUID) +{ + IMAPIdleOperation * op = new IMAPIdleOperation(); + op->setMainSession(this); + op->setFolder(folder); + op->setLastKnownUID(lastKnownUID); + op->autorelease(); + return op; +} + +IMAPFetchNamespaceOperation * IMAPAsyncSession::fetchNamespaceOperation() +{ + IMAPFetchNamespaceOperation * op = new IMAPFetchNamespaceOperation(); + op->setMainSession(this); + op->autorelease(); + return op; +} + +IMAPIdentityOperation * IMAPAsyncSession::identityOperation(IMAPIdentity * identity) +{ + IMAPIdentityOperation * op = new IMAPIdentityOperation(); + op->setMainSession(this); + op->setClientIdentity(identity); + op->autorelease(); + return op; +} + +IMAPOperation * IMAPAsyncSession::connectOperation() +{ + IMAPConnectOperation * op = new IMAPConnectOperation(); + op->setMainSession(this); + op->autorelease(); + return op; +} + +IMAPOperation * IMAPAsyncSession::checkAccountOperation() +{ + IMAPCheckAccountOperation * op = new IMAPCheckAccountOperation(); + op->setMainSession(this); + op->autorelease(); + return op; +} + +IMAPCapabilityOperation * IMAPAsyncSession::capabilityOperation() +{ + IMAPCapabilityOperation * op = new IMAPCapabilityOperation(); + op->setMainSession(this); + op->autorelease(); + return op; +} + +IMAPQuotaOperation * IMAPAsyncSession::quotaOperation() +{ + IMAPQuotaOperation * op = new IMAPQuotaOperation(); + op->setMainSession(this); + op->autorelease(); + return op; +} + +IMAPOperation * IMAPAsyncSession::noopOperation() +{ + IMAPNoopOperation * op = new IMAPNoopOperation(); + op->setMainSession(this); + op->autorelease(); + return op; +} + +IMAPOperation * IMAPAsyncSession::disconnectOperation() +{ + IMAPMultiDisconnectOperation * op = new IMAPMultiDisconnectOperation(); + op->autorelease(); + for(unsigned int i = 0 ; i < mSessions->count() ; i ++) { + IMAPAsyncConnection * currentSession = (IMAPAsyncConnection *) mSessions->objectAtIndex(i); + op->addOperation(currentSession->disconnectOperation()); + } + return op; +} + +void IMAPAsyncSession::setConnectionLogger(ConnectionLogger * logger) +{ + mConnectionLogger = logger; + for(unsigned int i = 0 ; i < mSessions->count() ; i ++) { + IMAPAsyncConnection * currentSession = (IMAPAsyncConnection *) mSessions->objectAtIndex(i); + currentSession->setConnectionLogger(logger); + } +} + +ConnectionLogger * IMAPAsyncSession::connectionLogger() +{ + return mConnectionLogger; +} + +IMAPMessageRenderingOperation * IMAPAsyncSession::renderingOperation(IMAPMessage * message, + String * folder, + IMAPMessageRenderingType type) +{ + IMAPMessageRenderingOperation * op = new IMAPMessageRenderingOperation(); + op->setMainSession(this); + op->setMessage(message); + op->setFolder(folder); + op->setRenderingType(type); + op->autorelease(); + return op; +} + +IMAPMessageRenderingOperation * IMAPAsyncSession::htmlRenderingOperation(IMAPMessage * message, + String * folder) +{ + return renderingOperation(message, folder, IMAPMessageRenderingTypeHTML); +} + +IMAPMessageRenderingOperation * IMAPAsyncSession::htmlBodyRenderingOperation(IMAPMessage * message, + String * folder) +{ + return renderingOperation(message, folder, IMAPMessageRenderingTypeHTMLBody); +} + +IMAPMessageRenderingOperation * IMAPAsyncSession::plainTextRenderingOperation(IMAPMessage * message, + String * folder) +{ + return renderingOperation(message, folder, IMAPMessageRenderingTypePlainText); +} + +IMAPMessageRenderingOperation * IMAPAsyncSession::plainTextBodyRenderingOperation(IMAPMessage * message, + String * folder, + bool stripWhitespace) +{ + return renderingOperation(message, folder, + stripWhitespace ? IMAPMessageRenderingTypePlainTextBodyAndStripWhitespace : + IMAPMessageRenderingTypePlainTextBody); +} + +void IMAPAsyncSession::automaticConfigurationDone(IMAPSession * session) +{ + MC_SAFE_REPLACE_COPY(IMAPIdentity, mServerIdentity, session->serverIdentity()); + MC_SAFE_REPLACE_COPY(String, mGmailUserDisplayName, session->gmailUserDisplayName()); + setDefaultNamespace(session->defaultNamespace()); + mAutomaticConfigurationDone = true; +} + +void IMAPAsyncSession::setOperationQueueCallback(OperationQueueCallback * callback) +{ + mOperationQueueCallback = callback; +} + +OperationQueueCallback * IMAPAsyncSession::operationQueueCallback() +{ + return mOperationQueueCallback; +} + +bool IMAPAsyncSession::isOperationQueueRunning() +{ + return mQueueRunning; +} + +void IMAPAsyncSession::cancelAllOperations() +{ + for(unsigned int i = 0 ; i < mSessions->count() ; i ++) { + IMAPAsyncConnection * currentSession = (IMAPAsyncConnection *) mSessions->objectAtIndex(i); + currentSession->cancelAllOperations(); + } +} + +void IMAPAsyncSession::operationRunningStateChanged() +{ + bool isRunning = false; + for(unsigned int i = 0 ; i < mSessions->count() ; i ++) { + IMAPAsyncConnection * currentSession = (IMAPAsyncConnection *) mSessions->objectAtIndex(i); + if (currentSession->isQueueRunning()){ + isRunning = true; + break; + } + } + if (mQueueRunning == isRunning) { + return; + } + mQueueRunning = isRunning; + if (mOperationQueueCallback != NULL) { + if (isRunning) { + mOperationQueueCallback->queueStartRunning(); + } + else { + mOperationQueueCallback->queueStoppedRunning(); + } + } +} + +#if __APPLE__ +void IMAPAsyncSession::setDispatchQueue(dispatch_queue_t dispatchQueue) +{ + if (mDispatchQueue != NULL) { + dispatch_release(mDispatchQueue); + } + mDispatchQueue = dispatchQueue; + if (mDispatchQueue != NULL) { + dispatch_retain(mDispatchQueue); + } +} + +dispatch_queue_t IMAPAsyncSession::dispatchQueue() +{ + return mDispatchQueue; +} +#endif |