Store store = sStores.get(uri);
       if (store == null) {
           if (uri.startsWith("imap")) {
               store = new ImapStore(storeConfig,
                       new DefaultTrustedSocketFactory(context),
                       (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE));
           } else if (uri.startsWith("pop3")) {
               store = new Pop3Store(storeConfig,
                       new DefaultTrustedSocketFactory(context));
           } else if (uri.startsWith("webdav")) {
               store = new WebDavStore(storeConfig);
           }

           if (store != null) {
               sStores.put(uri, store);
           }
       }

       if (store == null) {
           throw new MessagingException("Unable to locate an applicable Store for " + uri);
       }

       return store;
   }

public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
       if (view == mFooterView) {
           if (mCurrentFolder != null && !mSearch.isManualSearch()) {

               mController.loadMoreMessages(mAccount, mFolderName, null);

public void synchronizeMailbox(final Account account, final String folder, final MessagingListener listener, final Folder providedRemoteFolder) {
       putBackground("synchronizeMailbox", listener, new Runnable() {
           @Override
           public void run() {
               synchronizeMailboxSynchronous(account, folder, listener, providedRemoteFolder);
           }
       });
   }

for (MessagingListener l : getListeners(listener)) {
            l.synchronizeMailboxStarted(account, folder);
        }
        /*
         * We don't ever sync the Outbox or errors folder
         */
        if (folder.equals(account.getOutboxFolderName()) || folder.equals(account.getErrorFolderName())) {
            for (MessagingListener l : getListeners(listener)) {
                l.synchronizeMailboxFinished(account, folder, 0, 0);
            }

            return;
        }

final LocalStore localStore = account.getLocalStore();
           tLocalFolder = localStore.getFolder(folder);
           final LocalFolder localFolder = tLocalFolder;
           localFolder.open(Folder.OPEN_MODE_RW);
           localFolder.updateLastUid();
           List<? extends Message> localMessages = localFolder.getMessages(null);
           Map<String, Message> localUidMap = new HashMap<String, Message>();
           for (Message message : localMessages) {
               localUidMap.put(message.getUid(), message);
           }

           if (providedRemoteFolder != null) {
               remoteFolder = providedRemoteFolder;
           } else {
               Store remoteStore = account.getRemoteStore();
               remoteFolder = remoteStore.getFolder(folder);
               if (! verifyOrCreateRemoteSpecialFolder(account, folder, remoteFolder, listener)) {
                   return;
               }

remoteFolder.open(Folder.OPEN_MODE_RW);
             if (Expunge.EXPUNGE_ON_POLL == account.getExpungePolicy()) {
                 remoteFolder.expunge();
             }

         }

         /*
          * Get the remote message count.
          */
         int remoteMessageCount = remoteFolder.getMessageCount();

         int visibleLimit = localFolder.getVisibleLimit();

         if (visibleLimit < 0) {
             visibleLimit = K9.DEFAULT_VISIBLE_LIMIT;
         }

         final List<Message> remoteMessages = new ArrayList<Message>();
         Map<String, Message> remoteUidMap = new HashMap<String, Message>();

         final Date earliestDate = account.getEarliestPollDate();


         if (remoteMessageCount > 0) {
             /* Message numbers start at 1.  */
             int remoteStart;
             if (visibleLimit > 0) {
                 remoteStart = Math.max(0, remoteMessageCount - visibleLimit) + 1;
             } else {
                 remoteStart = 1;
             }
             int remoteEnd = remoteMessageCount;

             if (K9.DEBUG)
                 Log.v(K9.LOG_TAG, "SYNC: About to get messages " + remoteStart + " through " + remoteEnd + " for folder " + folder);

             final AtomicInteger headerProgress = new AtomicInteger(0);
             for (MessagingListener l : getListeners(listener)) {
                 l.synchronizeMailboxHeadersStarted(account, folder);
             }


             List<? extends Message> remoteMessageArray = remoteFolder.getMessages(remoteStart, remoteEnd, earliestDate, null);

             int messageCount = remoteMessageArray.size();

             for (Message thisMess : remoteMessageArray) {
                 headerProgress.incrementAndGet();
                 for (MessagingListener l : getListeners(listener)) {
                     l.synchronizeMailboxHeadersProgress(account, folder, headerProgress.get(), messageCount);
                 }
                 Message localMessage = localUidMap.get(thisMess.getUid());
                 if (localMessage == null || !localMessage.olderThan(earliestDate)) {
                     remoteMessages.add(thisMess);
                     remoteUidMap.put(thisMess.getUid(), thisMess);
                 }
             }

             for (MessagingListener l : getListeners(listener)) {
                 l.synchronizeMailboxHeadersFinished(account, folder, headerProgress.get(), remoteUidMap.size());
             }

         } else if (remoteMessageCount < 0) {
             throw new Exception("Message count " + remoteMessageCount + " for folder " + folder);
         }

/*
             * Remove any messages that are in the local store but no longer on the remote store or are too old
             */
            if (account.syncRemoteDeletions()) {
                List<Message> destroyMessages = new ArrayList<Message>();
                for (Message localMessage : localMessages) {
                    if (remoteUidMap.get(localMessage.getUid()) == null) {
                        destroyMessages.add(localMessage);
                    }
                }


                localFolder.destroyMessages(destroyMessages);

                for (Message destroyMessage : destroyMessages) {
                    for (MessagingListener l : getListeners(listener)) {
                        l.synchronizeMailboxRemovedMessage(account, folder, destroyMessage);
                    }
                }
            }

/*
             * Now we download the actual content of messages.
             */
            int newMessages = downloadMessages(account, remoteFolder, localFolder, remoteMessages, false);

            int unreadMessageCount = localFolder.getUnreadMessageCount();
            for (MessagingListener l : getListeners()) {
                l.folderStatusChanged(account, folder, unreadMessageCount);
            }

 * Grab the content of the small messages first. This is going to
 * be very fast and at very worst will be a single up of a few bytes and a single
 * download of 625k.
 */
FetchProfile fp = new FetchProfile();
fp.add(FetchProfile.Item.BODY);
//        fp.add(FetchProfile.Item.FLAGS);
//        fp.add(FetchProfile.Item.ENVELOPE);

downloadSmallMessages(account, remoteFolder, localFolder, smallMessages, progress, unreadBeforeStart, newMessages, todo, fp);
smallMessages.clear();

if (message.getBody() == null) {
   /*
  	* The provider was unable to get the structure of the message, so
   * we'll download a reasonable portion of the messge and mark it as
   * incomplete so the entire thing can be downloaded later if the user
   * wishes to download it.
   */
   fp.clear();
   fp.add(FetchProfile.Item.BODY_SANE);
   /*
    *  TODO a good optimization here would be to make sure that all Stores set
    *  the proper size after this fetch and compare the before and after size. If
    *  they equal we can mark this SYNCHRONIZED instead of PARTIALLY_SYNCHRONIZED
    */

   remoteFolder.fetch(Collections.singletonList(message), fp, null);

   // Store the updated message locally
   localFolder.appendMessages(Collections.singletonList(message));

   Message localMessage = localFolder.getMessage(message.getUid());


   // Certain (POP3) servers give you the whole message even when you ask for only the first x Kb
   if (!message.isSet(Flag.X_DOWNLOADED_FULL)) {
   /*
    * Mark the message as fully downloaded if the message size is smaller than
    * the account's autodownload size limit, otherwise mark as only a partial
    * download.  This will prevent the system from downloading the same message
    * twice.
    *
    * If there is no limit on autodownload size, that's the same as the message
    * being smaller than the max size
    */
   if (account.getMaximumAutoDownloadMessageSize() == 0 || message.getSize() < account.getMaximumAutoDownloadMessageSize()) {
       localMessage.setFlag(Flag.X_DOWNLOADED_FULL, true);
       } else {
       // Set a flag indicating that the message has been partially downloaded and
       // is ready for view.
       localMessage.setFlag(Flag.X_DOWNLOADED_PARTIAL, true;
       	}
       }
   } else {
       /*
        * We have a structure to deal with, from which
        * we can pull down the parts we want to actually store.
        * Build a list of parts we are interested in. Text parts will be downloaded
        * right now, attachments will be left for later.
        */

       Set<Part> viewables = MessageExtractor.collectTextParts(message);

       /*
        * Now download the parts we're interested in storing.
        */
       for (Part part : viewables) {
           remoteFolder.fetchPart(message, part, null);
       }
       // Store the updated message locally
       localFolder.appendMessages(Collections.singletonList(message));

       Message localMessage = localFolder.getMessage(message.getUid());
   }

// Set a flag indicating this message has been fully downloaded and can be viewed.
localMessage.setFlag(Flag.X_DOWNLOADED_PARTIAL, true);

for (MessagingListener l : getListeners()) {
    l.synchronizeMailboxAddOrUpdateMessage(account, folder, localMessage);
    l.synchronizeMailboxProgress(account, folder, progress.get(), todo);
    if (!localMessage.isSet(Flag.SEEN)) {
                    l.synchronizeMailboxNewMessage(account, folder, localMessage);
                        }
                    }

case R.id.send:
	mPgpData.setEncryptionKeys(null);
	onSend();
	break;

MessagingController.getInstance(getApplication()).sendMessage(mAccount, message, null);

LocalStore localStore = account.getLocalStore();
LocalFolder localFolder = localStore.getFolder(account.getOutboxFolderName());
localFolder.open(Folder.OPEN_MODE_RW);
localFolder.appendMessages(Collections.singletonList(message));
Message localMessage = localFolder.getMessage(message.getUid());
localMessage.setFlag(Flag.X_DOWNLOADED_FULL, true);
localFolder.close();
sendPendingMessages(account, listener);

Store localStore = account.getLocalStore();
localFolder = localStore.getFolder(
                  account.getOutboxFolderName());
if (!localFolder.exists()) {
    return;
}
for (MessagingListener l : getListeners()) {
    l.sendPendingMessagesStarted(account);
}
localFolder.open(Folder.OPEN_MODE_RW);

if (message.isSet(Flag.DELETED)) {
    message.destroy();
    continue;
	}

for (MessagingListener l : getListeners()) {
    l.synchronizeMailboxProgress(account, account.getSentFolderName(), progress, todo);
    }

localFolder.moveMessages(Collections.singletonList(message), localSentFolder);

if (mDisplayMode == DisplayMode.MESSAGE_LIST) {
    mMessageListFragment.onDelete();
} else if (mMessageViewFragment != null) {
    mMessageViewFragment.onDelete();
}

private void onDeleteConfirmed(List<LocalMessage> messages) {
        if (mThreadedList) {
            mController.deleteThreads(messages);
        } else {
            mController.deleteMessages(messages, null);
        }
    }

private void putBackground(String description, MessagingListener listener, Runnable runnable) {
        putCommand(mCommands, description, listener, runnable, false);

if (folder.equals(account.getTrashFolderName()) || !account.hasTrashFolder()) {
    localFolder.setFlags(messages, Collections.singleton(Flag.DELETED), true);
} else {
    localTrashFolder = localStore.getFolder(account.getTrashFolderName());
    if (!localTrashFolder.exists()) {
        localTrashFolder.create(Folder.FolderType.HOLDS_MESSAGES);
    }
    if (localTrashFolder.exists()) {
        uidMap = localFolder.moveMessages(messages, localTrashFolder);
    }
}

if (folder.equals(account.getOutboxFolderName())) {
    for (Message message : messages) {
    // If the message was in the Outbox, then it has been copied to local Trash, and has
    // to be copied to remote trash
        PendingCommand command = new PendingCommand();
        command.command = PENDING_COMMAND_APPEND;
        command.arguments =
            new String[] {
            account.getTrashFolderName(),
            message.getUid()
        };
        queuePendingCommand(account, command);
    }
    processPendingCommands(account);
} else if (account.getDeletePolicy() == DeletePolicy.ON_DELETE) {
    if (folder.equals(account.getTrashFolderName())) {
        queueSetFlag(account, folder, Boolean.toString(true), Flag.DELETED.toString(), uids);
    } else {
        queueMoveOrCopy(account, folder, account.getTrashFolderName(), false, uids, uidMap);
                }
        processPendingCommands(account);
    } else if (account.getDeletePolicy() == DeletePolicy.MARK_AS_READ) {
        queueSetFlag(account, folder, Boolean.toString(true), Flag.SEEN.toString(), uids);
        processPendingCommands(account);
    }

List<PendingCommand> commands = localStore.getPendingCommands();

Store remoteStore = account.getRemoteStore();
Folder remoteFolder = remoteStore.getFolder(folder);

remoteFolder.open(Folder.OPEN_MODE_RW);
if (remoteFolder.getMode() != Folder.OPEN_MODE_RW) {
    return;
}
remoteFolder.expunge();
} finally {
            closeFolder(remoteFolder);

mConnection.sendCommand(String.format("UID FETCH %s (%s)",
	combine(uidWindow.toArray(new String[uidWindow.size()]), ','),
    combine(fetchFields.toArray(new String[fetchFields.size()]), ' ')), false);
    ImapResponse response;
    int messageNumber = 0;

    ImapResponseCallback callback = null;
    if (fp.contains(FetchProfile.Item.BODY) || fp.contains(FetchProfile.Item.BODY_SANE)) {
        callback = new FetchBodyCallback(messageMap);
    }
    response = mConnection.readResponse(callback);

        ImapMessage imapMessage = (ImapMessage) message;

        Object literal = handleFetchResponse(imapMessage, fetchList);

String bodyString = (String)literal;
InputStream bodyStream = new ByteArrayInputStream(bodyString.getBytes());
imapMessage.parse(bodyStream);

private void parse(InputStream in, boolean recurse) throws IOException, MessagingException {
...

MimeStreamParser parser = new MimeStreamParser(parserConfig);
parser.setContentHandler(new MimeMessageBuilder());
if (recurse) {
    parser.setRecurse();
}
try {
    parser.parse(new EOLConvertingInputStream(in));
}
...

public void startHeader() {
    expect(Part.class);
}

private class MimeMessageBuilder implements ContentHandler

case T_BODY
BodyDescriptor desc = mimeTokenStream.getBodyDescriptor()
InputStream bodyContent
if (contentDecoding) 
    bodyContent = mimeTokenStream.getDecodedInputStream()
} else 
    bodyContent = mimeTokenStream.getInputStream()
    handler.body(desc, bodyContent)
break;

ContentValues cv = new ContentValues();
    cv.put("message_part_id", rootMessagePartId);
    cv.put("uid", uid);
    cv.put("subject", message.getSubject());
    cv.put("sender_list", Address.pack(message.getFrom()));
    cv.put("date", message.getSentDate() == null
            ? System.currentTimeMillis() : message.getSentDate().getTime());
    cv.put("flags", this.localStore.serializeFlags(message.getFlags()));
    cv.put("deleted", message.isSet(Flag.DELETED) ? 1 : 0);
    cv.put("read", message.isSet(Flag.SEEN) ? 1 : 0);
    cv.put("flagged", message.isSet(Flag.FLAGGED) ? 1 : 0);
    cv.put("answered", message.isSet(Flag.ANSWERED) ? 1 : 0);
    cv.put("forwarded", message.isSet(Flag.FORWARDED) ? 1 : 0);
    cv.put("folder_id", mFolderId);
    cv.put("to_list", Address.pack(message.getRecipients(RecipientType.TO)));
    cv.put("cc_list", Address.pack(message.getRecipients(RecipientType.CC)));
    cv.put("bcc_list", Address.pack(message.getRecipients(RecipientType.BCC)));
    cv.put("preview", preview);
    cv.put("reply_to_list", Address.pack(message.getReplyTo()));
    cv.put("attachment_count", attachmentCount);
    cv.put("internal_date", message.getInternalDate() == null
            ? System.currentTimeMillis() : message.getInternalDate().getTime());
    cv.put("mime_type", message.getMimeType());
    cv.put("empty", 0);

    String messageId = message.getMessageId();
    if (messageId != null) {
    cv.put("message_id", messageId);
    }

	if (oldMessageId == -1) {
    long msgId = db.insert("messages", "uid", cv);

    // Create entry in 'threads' table
    cv.clear();
    cv.put("message_id", msgId);

    if (rootId != -1) {
        cv.put("root", rootId);
    }
    if (parentId != -1) {
        cv.put("parent", parentId);
    }

    db.insert("threads", null, cv);
    } else {
    db.update("messages", cv, "id = ?", new String[] { Long.toString(oldMessageId) });
    }

XmlResourceParser xml = getResources().getXml(R.xml.providers);

<provider id="gmail" label="Gmail" domain="gmail.com">
    <incoming uri="imap+ssl+://imap.gmail.com" username="$email" />
    <outgoing uri="smtp+ssl+://smtp.gmail.com" username="$email" />
</provider>

private void finishAutoSetup() {
        String email = mEmailView.getText().toString();
        String password = mPasswordView.getText().toString();
        String[] emailParts = splitEmail(email);
        String user = emailParts[0];
        String domain = emailParts[1];
        try {
            String userEnc = UrlEncodingHelper.encodeUtf8(user);
            String passwordEnc = UrlEncodingHelper.encodeUtf8(password);

            String incomingUsername = mProvider.incomingUsernameTemplate;
            incomingUsername = incomingUsername.replaceAll("\\$email", email);
            incomingUsername = incomingUsername.replaceAll("\\$user", userEnc);
            incomingUsername = incomingUsername.replaceAll("\\$domain", domain);

            URI incomingUriTemplate = mProvider.incomingUriTemplate;
            URI incomingUri = new URI(incomingUriTemplate.getScheme(), incomingUsername + ":" + passwordEnc,
                    incomingUriTemplate.getHost(), incomingUriTemplate.getPort(), null, null, null);

            String outgoingUsername = mProvider.outgoingUsernameTemplate;

            URI outgoingUriTemplate = mProvider.outgoingUriTemplate;


            URI outgoingUri;
 			if (mAccount == null) {
                mAccount = Preferences.getPreferences(this).newAccount();
            }
            mAccount.setName(getOwnerName());
            mAccount.setEmail(email);
            mAccount.setStoreUri(incomingUri.toString());
            mAccount.setTransportUri(outgoingUri.toString());

            setupFolderNames(incomingUriTemplate.getHost().toLowerCase(Locale.US));

            ServerSettings incomingSettings = RemoteStore.decodeStoreUri(incomingUri.toString());
            mAccount.setDeletePolicy(AccountCreator.getDefaultDeletePolicy(incomingSettings.type));

            // Check incoming here.  Then check outgoing in onActivityResult()
            AccountSetupCheckSettings.actionCheckSettings(this, mAccount, CheckDirection.INCOMING);
        }

public static void actionCheckSettings(Activity context, Account account,
            CheckDirection direction) {
    Intent i = new Intent(context, AccountSetupCheckSettings.class);
    i.putExtra(EXTRA_ACCOUNT, account.getUuid());
    i.putExtra(EXTRA_CHECK_DIRECTION, direction);
    context.startActivityForResult(i, ACTIVITY_REQUEST_CODE);
}

new CheckAccountTask(mAccount).execute(mDirection);

clearCertificateErrorNotifications(direction);
checkServerSettings(direction);
setResult(RESULT_OK);
finish();

switch (direction) {
    case INCOMING: {
        checkIncoming();
        break;
    }
    case OUTGOING: {
        checkOutgoing();
        break;
    }
}

Store store = account.getRemoteStore()
publishProgress(R.string.account_setup_check_settings_check_incoming_msg);
store.checkSettings();
MessagingController.getInstance(getApplication()).listFoldersSynchronous(account, true, null);
MessagingController.getInstance(getApplication()).synchronizeMailbox(account, account.getInboxFolderName(), null, null);

Pop3Folder folder = new Pop3Folder(mStoreConfig.getInboxFolderName());
folder.open(Folder.OPEN_MODE_RW);

Store localStore = account.getLocalStore();
localFolders = localStore.getPersonalNamespaces(false);
if (refreshRemote || localFolders.isEmpty()) {
    doRefreshRemote(account, listener);
    return;
}

 for (Folder remoteFolder : remoteFolders) {
    if (localFolderNames.contains(remoteFolder.getName()) == false) {
        LocalFolder localFolder = localStore.getFolder(remoteFolder.getName());
        foldersToCreate.add(localFolder);
    }
    remoteFolderNames.add(remoteFolder.getName());
}

final File databaseFile = storageManager.getDatabase(uUid, providerId);
private void doOpenOrCreateDb(final File databaseFile) {
        if (StorageManager.InternalStorageProvider.ID.equals(mStorageProviderId)) {
            // internal storage
            mDb = context.openOrCreateDatabase(databaseFile.getName(), Context.MODE_PRIVATE,
                    null);
        } else {
            // external storage
            mDb = SQLiteDatabase.openOrCreateDatabase(databaseFile, null);
        }
    }

db.execSQL("CREATE TABLE folders (id INTEGER PRIMARY KEY, name TEXT, "
       + "last_updated INTEGER, unread_count INTEGER, visible_limit INTEGER, status TEXT, "
       + "push_state TEXT, last_pushed INTEGER, flagged_count INTEGER default 0, "
       + "integrate INTEGER, top_group INTEGER, poll_class TEXT, push_class TEXT, display_class TEXT, notify_class TEXT"
       + ")");

db.execSQL("CREATE TABLE messages (" +
        "id INTEGER PRIMARY KEY, " +
        "deleted INTEGER default 0, " +
        "folder_id INTEGER, " +
        "uid TEXT, " +
        "subject TEXT, " +
        "date INTEGER, " +
        "flags TEXT, " +
        "sender_list TEXT, " +
        "to_list TEXT, " +
        "cc_list TEXT, " +
        "bcc_list TEXT, " +
        "reply_to_list TEXT, " +
        "attachment_count INTEGER, " +
        "internal_date INTEGER, " +
        "message_id TEXT, " +
        "preview TEXT, " +
        "mime_type TEXT, "+
        "normalized_subject_hash INTEGER, " +
        "empty INTEGER, " +
        "read INTEGER default 0, " +
        "flagged INTEGER default 0, " +
        "answered INTEGER default 0, " +
        "forwarded INTEGER default 0, " +
        "message_part_id INTEGER" +
        ")");

db.execSQL("CREATE TRIGGER set_thread_root " +
    "AFTER INSERT ON threads " +
    "BEGIN " +
    "UPDATE threads SET root=id WHERE root IS NULL AND ROWID = NEW.ROWID; " +
    "END");

db.execSQL("CREATE TRIGGER delete_folder" +
	"BEFORE DELETE ON folders" +
	"BEGIN DELETE FROM messages WHERE old.id = folder_id;" +
	"END;");

db.execSQL("CREATE TRIGGER delete_message " +
   "BEFORE DELETE ON messages " +
   "BEGIN " +
   "DELETE FROM message_parts WHERE root = OLD.message_part_id;" +
   "END");