Examples with ImapString com.android.voicemail.impl.mail.store.imap.ImapString used on opensource projects

Example 1 with ImapString

use of com.android.voicemail.impl.mail.store.imap.ImapString in project android_packages_apps_Dialer by LineageOS.

the class ImapFolder method parseBodyStructure.

private static void parseBodyStructure(ImapList bs, Part part, String id) throws MessagingException {
    if (bs.getElementOrNone(0).isList()) {
        /*
       * This is a multipart/*
       */
        MimeMultipart mp = new MimeMultipart();
        for (int i = 0, count = bs.size(); i < count; i++) {
            ImapElement e = bs.getElementOrNone(i);
            if (e.isList()) {
                /*
           * For each part in the message we're going to add a new BodyPart and parse
           * into it.
           */
                MimeBodyPart bp = new MimeBodyPart();
                if (id.equals(ImapConstants.TEXT)) {
                    parseBodyStructure(bs.getListOrEmpty(i), bp, Integer.toString(i + 1));
                } else {
                    parseBodyStructure(bs.getListOrEmpty(i), bp, id + "." + (i + 1));
                }
                mp.addBodyPart(bp);
            } else {
                if (e.isString()) {
                    mp.setSubType(bs.getStringOrEmpty(i).getString().toLowerCase(Locale.US));
                }
                // Ignore the rest of the list.
                break;
            }
        }
        part.setBody(mp);
    } else {
        /*
       * This is a body. We need to add as much information as we can find out about
       * it to the Part.
       */
        /*
      body type
      body subtype
      body parameter parenthesized list
      body id
      body description
      body encoding
      body size
      */
        final ImapString type = bs.getStringOrEmpty(0);
        final ImapString subType = bs.getStringOrEmpty(1);
        final String mimeType = (type.getString() + "/" + subType.getString()).toLowerCase(Locale.US);
        final ImapList bodyParams = bs.getListOrEmpty(2);
        final ImapString cid = bs.getStringOrEmpty(3);
        final ImapString encoding = bs.getStringOrEmpty(5);
        final int size = bs.getStringOrEmpty(6).getNumberOrZero();
        if (MimeUtility.mimeTypeMatches(mimeType, MimeUtility.MIME_TYPE_RFC822)) {
            /*
         * This will be caught by fetch and handled appropriately.
         */
            throw new MessagingException("BODYSTRUCTURE " + MimeUtility.MIME_TYPE_RFC822 + " not yet supported.");
        }
        /*
       * Set the content type with as much information as we know right now.
       */
        final StringBuilder contentType = new StringBuilder(mimeType);
        /*
       * If there are body params we might be able to get some more information out
       * of them.
       */
        for (int i = 1, count = bodyParams.size(); i < count; i += 2) {
            // TODO We need to convert " into %22, but
            // because MimeUtility.getHeaderParameter doesn't recognize it,
            // we can't fix it for now.
            contentType.append(String.format(";\n %s=\"%s\"", bodyParams.getStringOrEmpty(i - 1).getString(), bodyParams.getStringOrEmpty(i).getString()));
        }
        part.setHeader(MimeHeader.HEADER_CONTENT_TYPE, contentType.toString());
        // Extension items
        final ImapList bodyDisposition;
        if (type.is(ImapConstants.TEXT) && bs.getElementOrNone(9).isList()) {
            // If media-type is TEXT, 9th element might be: [body-fld-lines] := number
            // So, if it's not a list, use 10th element.
            // (Couldn't find evidence in the RFC if it's ALWAYS 10th element.)
            bodyDisposition = bs.getListOrEmpty(9);
        } else {
            bodyDisposition = bs.getListOrEmpty(8);
        }
        final StringBuilder contentDisposition = new StringBuilder();
        if (bodyDisposition.size() > 0) {
            final String bodyDisposition0Str = bodyDisposition.getStringOrEmpty(0).getString().toLowerCase(Locale.US);
            if (!TextUtils.isEmpty(bodyDisposition0Str)) {
                contentDisposition.append(bodyDisposition0Str);
            }
            final ImapList bodyDispositionParams = bodyDisposition.getListOrEmpty(1);
            if (!bodyDispositionParams.isEmpty()) {
                /*
           * If there is body disposition information we can pull some more
           * information about the attachment out.
           */
                for (int i = 1, count = bodyDispositionParams.size(); i < count; i += 2) {
                    // TODO We need to convert " into %22.  See above.
                    contentDisposition.append(String.format(Locale.US, ";\n %s=\"%s\"", bodyDispositionParams.getStringOrEmpty(i - 1).getString().toLowerCase(Locale.US), bodyDispositionParams.getStringOrEmpty(i).getString()));
                }
            }
        }
        if ((size > 0) && (MimeUtility.getHeaderParameter(contentDisposition.toString(), "size") == null)) {
            contentDisposition.append(String.format(Locale.US, ";\n size=%d", size));
        }
        if (contentDisposition.length() > 0) {
            /*
         * Set the content disposition containing at least the size. Attachment
         * handling code will use this down the road.
         */
            part.setHeader(MimeHeader.HEADER_CONTENT_DISPOSITION, contentDisposition.toString());
        }
        /*
       * Set the Content-Transfer-Encoding header. Attachment code will use this
       * to parse the body.
       */
        if (!encoding.isEmpty()) {
            part.setHeader(MimeHeader.HEADER_CONTENT_TRANSFER_ENCODING, encoding.getString());
        }
        /*
       * Set the Content-ID header.
       */
        if (!cid.isEmpty()) {
            part.setHeader(MimeHeader.HEADER_CONTENT_ID, cid.getString());
        }
        if (size > 0) {
            if (part instanceof ImapMessage) {
                ((ImapMessage) part).setSize(size);
            } else if (part instanceof MimeBodyPart) {
                ((MimeBodyPart) part).setSize(size);
            } else {
                throw new MessagingException("Unknown part type " + part.toString());
            }
        }
        part.setHeader(MimeHeader.HEADER_ANDROID_ATTACHMENT_STORE_DATA, id);
    }
}

Example 2 with ImapString

use of com.android.voicemail.impl.mail.store.imap.ImapString in project android_packages_apps_Dialer by LineageOS.

the class ImapFolder method fetchInternal.

public void fetchInternal(Message[] messages, FetchProfile fp, MessageRetrievalListener listener) throws MessagingException {
    if (messages.length == 0) {
        return;
    }
    checkOpen();
    ArrayMap<String, Message> messageMap = new ArrayMap<String, Message>();
    for (Message m : messages) {
        messageMap.put(m.getUid(), m);
    }
    /*
     * Figure out what command we are going to run:
     * FLAGS     - UID FETCH (FLAGS)
     * ENVELOPE  - UID FETCH (INTERNALDATE UID RFC822.SIZE FLAGS BODY.PEEK[
     *                            HEADER.FIELDS (date subject from content-type to cc)])
     * STRUCTURE - UID FETCH (BODYSTRUCTURE)
     * BODY_SANE - UID FETCH (BODY.PEEK[]<0.N>) where N = max bytes returned
     * BODY      - UID FETCH (BODY.PEEK[])
     * Part      - UID FETCH (BODY.PEEK[ID]) where ID = mime part ID
     */
    final LinkedHashSet<String> fetchFields = new LinkedHashSet<String>();
    fetchFields.add(ImapConstants.UID);
    if (fp.contains(FetchProfile.Item.FLAGS)) {
        fetchFields.add(ImapConstants.FLAGS);
    }
    if (fp.contains(FetchProfile.Item.ENVELOPE)) {
        fetchFields.add(ImapConstants.INTERNALDATE);
        fetchFields.add(ImapConstants.RFC822_SIZE);
        fetchFields.add(ImapConstants.FETCH_FIELD_HEADERS);
    }
    if (fp.contains(FetchProfile.Item.STRUCTURE)) {
        fetchFields.add(ImapConstants.BODYSTRUCTURE);
    }
    if (fp.contains(FetchProfile.Item.BODY_SANE)) {
        fetchFields.add(ImapConstants.FETCH_FIELD_BODY_PEEK_SANE);
    }
    if (fp.contains(FetchProfile.Item.BODY)) {
        fetchFields.add(ImapConstants.FETCH_FIELD_BODY_PEEK);
    }
    // TODO Why are we only fetching the first part given?
    final Part fetchPart = fp.getFirstPart();
    if (fetchPart != null) {
        final String[] partIds = fetchPart.getHeader(MimeHeader.HEADER_ANDROID_ATTACHMENT_STORE_DATA);
        // the first id if there are more than one?
        if (partIds != null) {
            fetchFields.add(ImapConstants.FETCH_FIELD_BODY_PEEK_BARE + "[" + partIds[0] + "]");
        }
    }
    try {
        connection.sendCommand(String.format(Locale.US, ImapConstants.UID_FETCH + " %s (%s)", ImapStore.joinMessageUids(messages), Utility.combine(fetchFields.toArray(new String[fetchFields.size()]), ' ')), false);
        ImapResponse response;
        do {
            response = null;
            try {
                response = connection.readResponse();
                if (!response.isDataResponse(1, ImapConstants.FETCH)) {
                    // Ignore
                    continue;
                }
                final ImapList fetchList = response.getListOrEmpty(2);
                final String uid = fetchList.getKeyedStringOrEmpty(ImapConstants.UID).getString();
                if (TextUtils.isEmpty(uid))
                    continue;
                ImapMessage message = (ImapMessage) messageMap.get(uid);
                if (message == null)
                    continue;
                if (fp.contains(FetchProfile.Item.FLAGS)) {
                    final ImapList flags = fetchList.getKeyedListOrEmpty(ImapConstants.FLAGS);
                    for (int i = 0, count = flags.size(); i < count; i++) {
                        final ImapString flag = flags.getStringOrEmpty(i);
                        if (flag.is(ImapConstants.FLAG_DELETED)) {
                            message.setFlagInternal(Flag.DELETED, true);
                        } else if (flag.is(ImapConstants.FLAG_ANSWERED)) {
                            message.setFlagInternal(Flag.ANSWERED, true);
                        } else if (flag.is(ImapConstants.FLAG_SEEN)) {
                            message.setFlagInternal(Flag.SEEN, true);
                        } else if (flag.is(ImapConstants.FLAG_FLAGGED)) {
                            message.setFlagInternal(Flag.FLAGGED, true);
                        }
                    }
                }
                if (fp.contains(FetchProfile.Item.ENVELOPE)) {
                    final Date internalDate = fetchList.getKeyedStringOrEmpty(ImapConstants.INTERNALDATE).getDateOrNull();
                    final int size = fetchList.getKeyedStringOrEmpty(ImapConstants.RFC822_SIZE).getNumberOrZero();
                    final String header = fetchList.getKeyedStringOrEmpty(ImapConstants.BODY_BRACKET_HEADER, true).getString();
                    message.setInternalDate(internalDate);
                    message.setSize(size);
                    try {
                        message.parse(Utility.streamFromAsciiString(header));
                    } catch (Exception e) {
                        VvmLog.e(TAG, "Error parsing header %s", e);
                    }
                }
                if (fp.contains(FetchProfile.Item.STRUCTURE)) {
                    ImapList bs = fetchList.getKeyedListOrEmpty(ImapConstants.BODYSTRUCTURE);
                    if (!bs.isEmpty()) {
                        try {
                            parseBodyStructure(bs, message, ImapConstants.TEXT);
                        } catch (MessagingException e) {
                            VvmLog.v(TAG, "Error handling message", e);
                            message.setBody(null);
                        }
                    }
                }
                if (fp.contains(FetchProfile.Item.BODY) || fp.contains(FetchProfile.Item.BODY_SANE)) {
                    // Body is keyed by "BODY[]...".
                    // Previously used "BODY[..." but this can be confused with "BODY[HEADER..."
                    // TODO Should we accept "RFC822" as well??
                    ImapString body = fetchList.getKeyedStringOrEmpty("BODY[]", true);
                    InputStream bodyStream = body.getAsStream();
                    try {
                        message.parse(bodyStream);
                    } catch (Exception e) {
                        VvmLog.e(TAG, "Error parsing body %s", e);
                    }
                }
                if (fetchPart != null) {
                    InputStream bodyStream = fetchList.getKeyedStringOrEmpty("BODY[", true).getAsStream();
                    String[] encodings = fetchPart.getHeader(MimeHeader.HEADER_CONTENT_TRANSFER_ENCODING);
                    String contentTransferEncoding = null;
                    if (encodings != null && encodings.length > 0) {
                        contentTransferEncoding = encodings[0];
                    } else {
                        // According to http://tools.ietf.org/html/rfc2045#section-6.1
                        // "7bit" is the default.
                        contentTransferEncoding = "7bit";
                    }
                    try {
                        // TODO Don't create 2 temp files.
                        // decodeBody creates BinaryTempFileBody, but we could avoid this
                        // if we implement ImapStringBody.
                        // (We'll need to share a temp file.  Protect it with a ref-count.)
                        message.setBody(decodeBody(store.getContext(), bodyStream, contentTransferEncoding, fetchPart.getSize(), listener));
                    } catch (Exception e) {
                        // TODO: Figure out what kinds of exceptions might actually be thrown
                        // from here. This blanket catch-all is because we're not sure what to
                        // do if we don't have a contentTransferEncoding, and we don't have
                        // time to figure out what exceptions might be thrown.
                        VvmLog.e(TAG, "Error fetching body %s", e);
                    }
                }
                if (listener != null) {
                    listener.messageRetrieved(message);
                }
            } finally {
                destroyResponses();
            }
        } while (!response.isTagged());
    } catch (IOException ioe) {
        store.getImapHelper().handleEvent(OmtpEvents.DATA_GENERIC_IMAP_IOE);
        throw ioExceptionHandler(connection, ioe);
    }
}

Example 3 with ImapString

use of com.android.voicemail.impl.mail.store.imap.ImapString in project android_packages_apps_Dialer by LineageOS.

the class ImapFolder method doSelect.

/**
 * Selects the folder for use. Before performing any operations on this folder, it must be
 * selected.
 */
private void doSelect() throws IOException, MessagingException {
    final List<ImapResponse> responses = connection.executeSimpleCommand(String.format(Locale.US, ImapConstants.SELECT + " \"%s\"", name));
    // Assume the folder is opened read-write; unless we are notified otherwise
    mode = MODE_READ_WRITE;
    int messageCount = -1;
    for (ImapResponse response : responses) {
        if (response.isDataResponse(1, ImapConstants.EXISTS)) {
            messageCount = response.getStringOrEmpty(0).getNumberOrZero();
        } else if (response.isOk()) {
            final ImapString responseCode = response.getResponseCodeOrEmpty();
            if (responseCode.is(ImapConstants.READ_ONLY)) {
                mode = MODE_READ_ONLY;
            } else if (responseCode.is(ImapConstants.READ_WRITE)) {
                mode = MODE_READ_WRITE;
            }
        } else if (response.isTagged()) {
            // Not OK
            store.getImapHelper().handleEvent(OmtpEvents.DATA_MAILBOX_OPEN_FAILED);
            throw new MessagingException("Can't open mailbox: " + response.getStatusResponseTextOrEmpty());
        }
    }
    if (messageCount == -1) {
        throw new MessagingException("Did not find message count during select");
    }
    this.messageCount = messageCount;
    exists = true;
}