| /* |
| * Copyright (C) 2010 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| package com.android.vcard; |
| |
| import android.text.TextUtils; |
| import android.util.Base64; |
| import android.util.Log; |
| |
| import com.android.vcard.exception.VCardAgentNotSupportedException; |
| import com.android.vcard.exception.VCardException; |
| import com.android.vcard.exception.VCardInvalidCommentLineException; |
| import com.android.vcard.exception.VCardInvalidLineException; |
| import com.android.vcard.exception.VCardVersionException; |
| |
| import java.io.BufferedReader; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.InputStreamReader; |
| import java.io.Reader; |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Set; |
| |
| /** |
| * <p> |
| * Basic implementation achieving vCard parsing. Based on vCard 2.1. |
| * </p> |
| * @hide |
| */ |
| /* package */ class VCardParserImpl_V21 { |
| private static final String LOG_TAG = VCardConstants.LOG_TAG; |
| |
| protected static final class CustomBufferedReader extends BufferedReader { |
| private long mTime; |
| |
| /** |
| * Needed since "next line" may be null due to end of line. |
| */ |
| private boolean mNextLineIsValid; |
| private String mNextLine; |
| |
| public CustomBufferedReader(Reader in) { |
| super(in); |
| } |
| |
| @Override |
| public String readLine() throws IOException { |
| if (mNextLineIsValid) { |
| final String ret = mNextLine; |
| mNextLine = null; |
| mNextLineIsValid = false; |
| return ret; |
| } |
| |
| final long start = System.currentTimeMillis(); |
| final String line = super.readLine(); |
| final long end = System.currentTimeMillis(); |
| mTime += end - start; |
| return line; |
| } |
| |
| /** |
| * Read one line, but make this object store it in its queue. |
| */ |
| public String peekLine() throws IOException { |
| if (!mNextLineIsValid) { |
| final long start = System.currentTimeMillis(); |
| final String line = super.readLine(); |
| final long end = System.currentTimeMillis(); |
| mTime += end - start; |
| |
| mNextLine = line; |
| mNextLineIsValid = true; |
| } |
| |
| return mNextLine; |
| } |
| |
| public long getTotalmillisecond() { |
| return mTime; |
| } |
| } |
| |
| private static final String DEFAULT_ENCODING = "8BIT"; |
| private static final String DEFAULT_CHARSET = "UTF-8"; |
| |
| protected final String mIntermediateCharset; |
| |
| private final List<VCardInterpreter> mInterpreterList = new ArrayList<VCardInterpreter>(); |
| private boolean mCanceled; |
| |
| /** |
| * <p> |
| * The encoding type for deconding byte streams. This member variable is |
| * reset to a default encoding every time when a new item comes. |
| * </p> |
| * <p> |
| * "Encoding" in vCard is different from "Charset". It is mainly used for |
| * addresses, notes, images. "7BIT", "8BIT", "BASE64", and |
| * "QUOTED-PRINTABLE" are known examples. |
| * </p> |
| */ |
| protected String mCurrentEncoding; |
| |
| protected String mCurrentCharset; |
| |
| /** |
| * <p> |
| * The reader object to be used internally. |
| * </p> |
| * <p> |
| * Developers should not directly read a line from this object. Use |
| * getLine() unless there some reason. |
| * </p> |
| */ |
| protected CustomBufferedReader mReader; |
| |
| /** |
| * <p> |
| * Set for storing unkonwn TYPE attributes, which is not acceptable in vCard |
| * specification, but happens to be seen in real world vCard. |
| * </p> |
| * <p> |
| * We just accept those invalid types after emitting a warning for each of it. |
| * </p> |
| */ |
| protected final Set<String> mUnknownTypeSet = new HashSet<String>(); |
| |
| /** |
| * <p> |
| * Set for storing unkonwn VALUE attributes, which is not acceptable in |
| * vCard specification, but happens to be seen in real world vCard. |
| * </p> |
| * <p> |
| * We just accept those invalid types after emitting a warning for each of it. |
| * </p> |
| */ |
| protected final Set<String> mUnknownValueSet = new HashSet<String>(); |
| |
| |
| public VCardParserImpl_V21() { |
| this(VCardConfig.VCARD_TYPE_DEFAULT); |
| } |
| |
| public VCardParserImpl_V21(int vcardType) { |
| mIntermediateCharset = VCardConfig.DEFAULT_INTERMEDIATE_CHARSET; |
| } |
| |
| /** |
| * @return true when a given property name is a valid property name. |
| */ |
| protected boolean isValidPropertyName(final String propertyName) { |
| if (!(getKnownPropertyNameSet().contains(propertyName.toUpperCase()) || |
| propertyName.startsWith("X-")) |
| && !mUnknownTypeSet.contains(propertyName)) { |
| mUnknownTypeSet.add(propertyName); |
| Log.w(LOG_TAG, "Property name unsupported by vCard 2.1: " + propertyName); |
| } |
| return true; |
| } |
| |
| /** |
| * @return String. It may be null, or its length may be 0 |
| * @throws IOException |
| */ |
| protected String getLine() throws IOException { |
| return mReader.readLine(); |
| } |
| |
| protected String peekLine() throws IOException { |
| return mReader.peekLine(); |
| } |
| |
| /** |
| * @return String with it's length > 0 |
| * @throws IOException |
| * @throws VCardException when the stream reached end of line |
| */ |
| protected String getNonEmptyLine() throws IOException, VCardException { |
| String line; |
| while (true) { |
| line = getLine(); |
| if (line == null) { |
| throw new VCardException("Reached end of buffer."); |
| } else if (line.trim().length() > 0) { |
| return line; |
| } |
| } |
| } |
| |
| /** |
| * <code> |
| * vcard = "BEGIN" [ws] ":" [ws] "VCARD" [ws] 1*CRLF |
| * items *CRLF |
| * "END" [ws] ":" [ws] "VCARD" |
| * </code> |
| * @return False when reaching end of file. |
| */ |
| private boolean parseOneVCard() throws IOException, VCardException { |
| // reset for this entire vCard. |
| mCurrentEncoding = DEFAULT_ENCODING; |
| mCurrentCharset = DEFAULT_CHARSET; |
| |
| boolean allowGarbage = false; |
| if (!readBeginVCard(allowGarbage)) { |
| return false; |
| } |
| for (VCardInterpreter interpreter : mInterpreterList) { |
| interpreter.onEntryStarted(); |
| } |
| parseItems(); |
| for (VCardInterpreter interpreter : mInterpreterList) { |
| interpreter.onEntryEnded(); |
| } |
| return true; |
| } |
| |
| /** |
| * @return True when successful. False when reaching the end of line |
| * @throws IOException |
| * @throws VCardException |
| */ |
| protected boolean readBeginVCard(boolean allowGarbage) throws IOException, VCardException { |
| // TODO: use consructPropertyLine(). |
| String line; |
| do { |
| while (true) { |
| line = getLine(); |
| if (line == null) { |
| return false; |
| } else if (line.trim().length() > 0) { |
| break; |
| } |
| } |
| final String[] strArray = line.split(":", 2); |
| final int length = strArray.length; |
| |
| // Although vCard 2.1/3.0 specification does not allow lower cases, |
| // we found vCard file emitted by some external vCard expoter have such |
| // invalid Strings. |
| // e.g. BEGIN:vCard |
| if (length == 2 && strArray[0].trim().equalsIgnoreCase("BEGIN") |
| && strArray[1].trim().equalsIgnoreCase("VCARD")) { |
| return true; |
| } else if (!allowGarbage) { |
| throw new VCardException("Expected String \"BEGIN:VCARD\" did not come " |
| + "(Instead, \"" + line + "\" came)"); |
| } |
| } while (allowGarbage); |
| |
| throw new VCardException("Reached where must not be reached."); |
| } |
| |
| /** |
| * Parses lines other than the first "BEGIN:VCARD". Takes care of "END:VCARD"n and |
| * "BEGIN:VCARD" in nested vCard. |
| */ |
| /* |
| * items = *CRLF item / item |
| * |
| * Note: BEGIN/END aren't include in the original spec while this method handles them. |
| */ |
| protected void parseItems() throws IOException, VCardException { |
| boolean ended = false; |
| |
| try { |
| ended = parseItem(); |
| } catch (VCardInvalidCommentLineException e) { |
| Log.e(LOG_TAG, "Invalid line which looks like some comment was found. Ignored."); |
| } |
| |
| while (!ended) { |
| try { |
| ended = parseItem(); |
| } catch (VCardInvalidCommentLineException e) { |
| Log.e(LOG_TAG, "Invalid line which looks like some comment was found. Ignored."); |
| } |
| } |
| } |
| |
| /* |
| * item = [groups "."] name [params] ":" value CRLF / [groups "."] "ADR" |
| * [params] ":" addressparts CRLF / [groups "."] "ORG" [params] ":" orgparts |
| * CRLF / [groups "."] "N" [params] ":" nameparts CRLF / [groups "."] |
| * "AGENT" [params] ":" vcard CRLF |
| */ |
| protected boolean parseItem() throws IOException, VCardException { |
| // Reset for an item. |
| mCurrentEncoding = DEFAULT_ENCODING; |
| |
| final String line = getNonEmptyLine(); |
| final VCardProperty propertyData = constructPropertyData(line); |
| |
| final String propertyNameUpper = propertyData.getName().toUpperCase(); |
| final String propertyRawValue = propertyData.getRawValue(); |
| |
| if (propertyNameUpper.equals(VCardConstants.PROPERTY_BEGIN)) { |
| if (propertyRawValue.equalsIgnoreCase("VCARD")) { |
| handleNest(); |
| } else { |
| throw new VCardException("Unknown BEGIN type: " + propertyRawValue); |
| } |
| } else if (propertyNameUpper.equals(VCardConstants.PROPERTY_END)) { |
| if (propertyRawValue.equalsIgnoreCase("VCARD")) { |
| return true; // Ended. |
| } else { |
| throw new VCardException("Unknown END type: " + propertyRawValue); |
| } |
| } else { |
| parseItemInter(propertyData, propertyNameUpper); |
| } |
| return false; |
| } |
| |
| private void parseItemInter(VCardProperty property, String propertyNameUpper) |
| throws IOException, VCardException { |
| String propertyRawValue = property.getRawValue(); |
| if (propertyNameUpper.equals(VCardConstants.PROPERTY_AGENT)) { |
| handleAgent(property); |
| } else if (isValidPropertyName(propertyNameUpper)) { |
| if (propertyNameUpper.equals(VCardConstants.PROPERTY_VERSION) && |
| !propertyRawValue.equals(getVersionString())) { |
| throw new VCardVersionException( |
| "Incompatible version: " + propertyRawValue + " != " + getVersionString()); |
| } |
| handlePropertyValue(property, propertyNameUpper); |
| } else { |
| throw new VCardException("Unknown property name: \"" + propertyNameUpper + "\""); |
| } |
| } |
| |
| private void handleNest() throws IOException, VCardException { |
| for (VCardInterpreter interpreter : mInterpreterList) { |
| interpreter.onEntryStarted(); |
| } |
| parseItems(); |
| for (VCardInterpreter interpreter : mInterpreterList) { |
| interpreter.onEntryEnded(); |
| } |
| } |
| |
| // For performance reason, the states for group and property name are merged into one. |
| static private final int STATE_GROUP_OR_PROPERTY_NAME = 0; |
| static private final int STATE_PARAMS = 1; |
| // vCard 3.0 specification allows double-quoted parameters, while vCard 2.1 does not. |
| static private final int STATE_PARAMS_IN_DQUOTE = 2; |
| |
| protected VCardProperty constructPropertyData(String line) throws VCardException { |
| final VCardProperty propertyData = new VCardProperty(); |
| |
| final int length = line.length(); |
| if (length > 0 && line.charAt(0) == '#') { |
| throw new VCardInvalidCommentLineException(); |
| } |
| |
| int state = STATE_GROUP_OR_PROPERTY_NAME; |
| int nameIndex = 0; |
| |
| // This loop is developed so that we don't have to take care of bottle neck here. |
| // Refactor carefully when you need to do so. |
| for (int i = 0; i < length; i++) { |
| final char ch = line.charAt(i); |
| switch (state) { |
| case STATE_GROUP_OR_PROPERTY_NAME: { |
| if (ch == ':') { // End of a property name. |
| final String propertyName = line.substring(nameIndex, i); |
| propertyData.setName(propertyName); |
| propertyData.setRawValue( i < length - 1 ? line.substring(i + 1) : ""); |
| return propertyData; |
| } else if (ch == '.') { // Each group is followed by the dot. |
| final String groupName = line.substring(nameIndex, i); |
| if (groupName.length() == 0) { |
| Log.w(LOG_TAG, "Empty group found. Ignoring."); |
| } else { |
| propertyData.addGroup(groupName); |
| } |
| nameIndex = i + 1; // Next should be another group or a property name. |
| } else if (ch == ';') { // End of property name and beginneng of parameters. |
| final String propertyName = line.substring(nameIndex, i); |
| propertyData.setName(propertyName); |
| nameIndex = i + 1; |
| state = STATE_PARAMS; // Start parameter parsing. |
| } |
| // TODO: comma support (in vCard 3.0 and 4.0). |
| break; |
| } |
| case STATE_PARAMS: { |
| if (ch == '"') { |
| if (VCardConstants.VERSION_V21.equalsIgnoreCase(getVersionString())) { |
| Log.w(LOG_TAG, "Double-quoted params found in vCard 2.1. " + |
| "Silently allow it"); |
| } |
| state = STATE_PARAMS_IN_DQUOTE; |
| } else if (ch == ';') { // Starts another param. |
| handleParams(propertyData, line.substring(nameIndex, i)); |
| nameIndex = i + 1; |
| } else if (ch == ':') { // End of param and beginenning of values. |
| handleParams(propertyData, line.substring(nameIndex, i)); |
| propertyData.setRawValue(i < length - 1 ? line.substring(i + 1) : ""); |
| return propertyData; |
| } |
| break; |
| } |
| case STATE_PARAMS_IN_DQUOTE: { |
| if (ch == '"') { |
| if (VCardConstants.VERSION_V21.equalsIgnoreCase(getVersionString())) { |
| Log.w(LOG_TAG, "Double-quoted params found in vCard 2.1. " + |
| "Silently allow it"); |
| } |
| state = STATE_PARAMS; |
| } |
| break; |
| } |
| } |
| } |
| |
| throw new VCardInvalidLineException("Invalid line: \"" + line + "\""); |
| } |
| |
| /* |
| * params = ";" [ws] paramlist paramlist = paramlist [ws] ";" [ws] param / |
| * param param = "TYPE" [ws] "=" [ws] ptypeval / "VALUE" [ws] "=" [ws] |
| * pvalueval / "ENCODING" [ws] "=" [ws] pencodingval / "CHARSET" [ws] "=" |
| * [ws] charsetval / "LANGUAGE" [ws] "=" [ws] langval / "X-" word [ws] "=" |
| * [ws] word / knowntype |
| */ |
| protected void handleParams(VCardProperty propertyData, String params) |
| throws VCardException { |
| final String[] strArray = params.split("=", 2); |
| if (strArray.length == 2) { |
| final String paramName = strArray[0].trim().toUpperCase(); |
| String paramValue = strArray[1].trim(); |
| if (paramName.equals("TYPE")) { |
| handleType(propertyData, paramValue); |
| } else if (paramName.equals("VALUE")) { |
| handleValue(propertyData, paramValue); |
| } else if (paramName.equals("ENCODING")) { |
| handleEncoding(propertyData, paramValue.toUpperCase()); |
| } else if (paramName.equals("CHARSET")) { |
| handleCharset(propertyData, paramValue); |
| } else if (paramName.equals("LANGUAGE")) { |
| handleLanguage(propertyData, paramValue); |
| } else if (paramName.startsWith("X-")) { |
| handleAnyParam(propertyData, paramName, paramValue); |
| } else { |
| throw new VCardException("Unknown type \"" + paramName + "\""); |
| } |
| } else { |
| handleParamWithoutName(propertyData, strArray[0]); |
| } |
| } |
| |
| /** |
| * vCard 3.0 parser implementation may throw VCardException. |
| */ |
| protected void handleParamWithoutName(VCardProperty propertyData, final String paramValue) { |
| handleType(propertyData, paramValue); |
| } |
| |
| /* |
| * ptypeval = knowntype / "X-" word |
| */ |
| protected void handleType(VCardProperty propertyData, final String ptypeval) { |
| if (!(getKnownTypeSet().contains(ptypeval.toUpperCase()) |
| || ptypeval.startsWith("X-")) |
| && !mUnknownTypeSet.contains(ptypeval)) { |
| mUnknownTypeSet.add(ptypeval); |
| Log.w(LOG_TAG, String.format("TYPE unsupported by %s: ", getVersion(), ptypeval)); |
| } |
| propertyData.addParameter(VCardConstants.PARAM_TYPE, ptypeval); |
| } |
| |
| /* |
| * pvalueval = "INLINE" / "URL" / "CONTENT-ID" / "CID" / "X-" word |
| */ |
| protected void handleValue(VCardProperty propertyData, final String pvalueval) { |
| if (!(getKnownValueSet().contains(pvalueval.toUpperCase()) |
| || pvalueval.startsWith("X-") |
| || mUnknownValueSet.contains(pvalueval))) { |
| mUnknownValueSet.add(pvalueval); |
| Log.w(LOG_TAG, String.format( |
| "The value unsupported by TYPE of %s: ", getVersion(), pvalueval)); |
| } |
| propertyData.addParameter(VCardConstants.PARAM_VALUE, pvalueval); |
| } |
| |
| /* |
| * pencodingval = "7BIT" / "8BIT" / "QUOTED-PRINTABLE" / "BASE64" / "X-" word |
| */ |
| protected void handleEncoding(VCardProperty propertyData, String pencodingval) |
| throws VCardException { |
| if (getAvailableEncodingSet().contains(pencodingval) || |
| pencodingval.startsWith("X-")) { |
| propertyData.addParameter(VCardConstants.PARAM_ENCODING, pencodingval); |
| // Update encoding right away, as this is needed to understanding other params. |
| mCurrentEncoding = pencodingval.toUpperCase(); |
| } else { |
| throw new VCardException("Unknown encoding \"" + pencodingval + "\""); |
| } |
| } |
| |
| /** |
| * <p> |
| * vCard 2.1 specification only allows us-ascii and iso-8859-xxx (See RFC 1521), |
| * but recent vCard files often contain other charset like UTF-8, SHIFT_JIS, etc. |
| * We allow any charset. |
| * </p> |
| */ |
| protected void handleCharset(VCardProperty propertyData, String charsetval) { |
| mCurrentCharset = charsetval; |
| propertyData.addParameter(VCardConstants.PARAM_CHARSET, charsetval); |
| } |
| |
| /** |
| * See also Section 7.1 of RFC 1521 |
| */ |
| protected void handleLanguage(VCardProperty propertyData, String langval) |
| throws VCardException { |
| String[] strArray = langval.split("-"); |
| if (strArray.length != 2) { |
| throw new VCardException("Invalid Language: \"" + langval + "\""); |
| } |
| String tmp = strArray[0]; |
| int length = tmp.length(); |
| for (int i = 0; i < length; i++) { |
| if (!isAsciiLetter(tmp.charAt(i))) { |
| throw new VCardException("Invalid Language: \"" + langval + "\""); |
| } |
| } |
| tmp = strArray[1]; |
| length = tmp.length(); |
| for (int i = 0; i < length; i++) { |
| if (!isAsciiLetter(tmp.charAt(i))) { |
| throw new VCardException("Invalid Language: \"" + langval + "\""); |
| } |
| } |
| propertyData.addParameter(VCardConstants.PARAM_LANGUAGE, langval); |
| } |
| |
| private boolean isAsciiLetter(char ch) { |
| if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')) { |
| return true; |
| } |
| return false; |
| } |
| |
| /** |
| * Mainly for "X-" type. This accepts any kind of type without check. |
| */ |
| protected void handleAnyParam( |
| VCardProperty propertyData, String paramName, String paramValue) { |
| propertyData.addParameter(paramName, paramValue); |
| } |
| |
| protected void handlePropertyValue(VCardProperty property, String propertyName) |
| throws IOException, VCardException { |
| final String propertyNameUpper = property.getName().toUpperCase(); |
| String propertyRawValue = property.getRawValue(); |
| final String sourceCharset = VCardConfig.DEFAULT_INTERMEDIATE_CHARSET; |
| final Collection<String> charsetCollection = |
| property.getParameters(VCardConstants.PARAM_CHARSET); |
| String targetCharset = |
| ((charsetCollection != null) ? charsetCollection.iterator().next() : null); |
| if (TextUtils.isEmpty(targetCharset)) { |
| targetCharset = VCardConfig.DEFAULT_IMPORT_CHARSET; |
| } |
| |
| // TODO: have "separableProperty" which reflects vCard spec.. |
| if (propertyNameUpper.equals(VCardConstants.PROPERTY_ADR) |
| || propertyNameUpper.equals(VCardConstants.PROPERTY_ORG) |
| || propertyNameUpper.equals(VCardConstants.PROPERTY_N)) { |
| handleAdrOrgN(property, propertyRawValue, sourceCharset, targetCharset); |
| return; |
| } |
| |
| if (mCurrentEncoding.equals(VCardConstants.PARAM_ENCODING_QP) || |
| // If encoding attribute is missing, then attempt to detect QP encoding. |
| // This is to handle a bug where the android exporter was creating FN properties |
| // with missing encoding. b/7292017 |
| (propertyNameUpper.equals(VCardConstants.PROPERTY_FN) && |
| property.getParameters(VCardConstants.PARAM_ENCODING) == null && |
| VCardUtils.appearsLikeAndroidVCardQuotedPrintable(propertyRawValue)) |
| ) { |
| final String quotedPrintablePart = getQuotedPrintablePart(propertyRawValue); |
| final String propertyEncodedValue = |
| VCardUtils.parseQuotedPrintable(quotedPrintablePart, |
| false, sourceCharset, targetCharset); |
| property.setRawValue(quotedPrintablePart); |
| property.setValues(propertyEncodedValue); |
| for (VCardInterpreter interpreter : mInterpreterList) { |
| interpreter.onPropertyCreated(property); |
| } |
| } else if (mCurrentEncoding.equals(VCardConstants.PARAM_ENCODING_BASE64) |
| || mCurrentEncoding.equals(VCardConstants.PARAM_ENCODING_B)) { |
| // It is very rare, but some BASE64 data may be so big that |
| // OutOfMemoryError occurs. To ignore such cases, use try-catch. |
| try { |
| final String base64Property = getBase64(propertyRawValue); |
| try { |
| property.setByteValue(Base64.decode(base64Property, Base64.DEFAULT)); |
| } catch (IllegalArgumentException e) { |
| throw new VCardException("Decode error on base64 photo: " + propertyRawValue); |
| } |
| for (VCardInterpreter interpreter : mInterpreterList) { |
| interpreter.onPropertyCreated(property); |
| } |
| } catch (OutOfMemoryError error) { |
| Log.e(LOG_TAG, "OutOfMemoryError happened during parsing BASE64 data!"); |
| for (VCardInterpreter interpreter : mInterpreterList) { |
| interpreter.onPropertyCreated(property); |
| } |
| } |
| } else { |
| if (!(mCurrentEncoding.equals("7BIT") || mCurrentEncoding.equals("8BIT") || |
| mCurrentEncoding.startsWith("X-"))) { |
| Log.w(LOG_TAG, |
| String.format("The encoding \"%s\" is unsupported by vCard %s", |
| mCurrentEncoding, getVersionString())); |
| } |
| |
| // Some device uses line folding defined in RFC 2425, which is not allowed |
| // in vCard 2.1 (while needed in vCard 3.0). |
| // |
| // e.g. |
| // BEGIN:VCARD |
| // VERSION:2.1 |
| // N:;Omega;;; |
| // EMAIL;INTERNET:"Omega" |
| // <omega@example.com> |
| // FN:Omega |
| // END:VCARD |
| // |
| // The vCard above assumes that email address should become: |
| // "Omega" <omega@example.com> |
| // |
| // But vCard 2.1 requires Quote-Printable when a line contains line break(s). |
| // |
| // For more information about line folding, |
| // see "5.8.1. Line delimiting and folding" in RFC 2425. |
| // |
| // We take care of this case more formally in vCard 3.0, so we only need to |
| // do this in vCard 2.1. |
| if (getVersion() == VCardConfig.VERSION_21) { |
| StringBuilder builder = null; |
| while (true) { |
| final String nextLine = peekLine(); |
| // We don't need to care too much about this exceptional case, |
| // but we should not wrongly eat up "END:VCARD", since it critically |
| // breaks this parser's state machine. |
| // Thus we roughly look over the next line and confirm it is at least not |
| // "END:VCARD". This extra fee is worth paying. This is exceptional |
| // anyway. |
| if (!TextUtils.isEmpty(nextLine) && |
| nextLine.charAt(0) == ' ' && |
| !"END:VCARD".contains(nextLine.toUpperCase())) { |
| getLine(); // Drop the next line. |
| |
| if (builder == null) { |
| builder = new StringBuilder(); |
| builder.append(propertyRawValue); |
| } |
| builder.append(nextLine.substring(1)); |
| } else { |
| break; |
| } |
| } |
| if (builder != null) { |
| propertyRawValue = builder.toString(); |
| } |
| } |
| |
| ArrayList<String> propertyValueList = new ArrayList<String>(); |
| String value = VCardUtils.convertStringCharset( |
| maybeUnescapeText(propertyRawValue), sourceCharset, targetCharset); |
| propertyValueList.add(value); |
| property.setValues(propertyValueList); |
| for (VCardInterpreter interpreter : mInterpreterList) { |
| interpreter.onPropertyCreated(property); |
| } |
| } |
| } |
| |
| private void handleAdrOrgN(VCardProperty property, String propertyRawValue, |
| String sourceCharset, String targetCharset) throws VCardException, IOException { |
| List<String> encodedValueList = new ArrayList<String>(); |
| |
| // vCard 2.1 does not allow QUOTED-PRINTABLE here, but some softwares/devices emit |
| // such data. |
| if (mCurrentEncoding.equals(VCardConstants.PARAM_ENCODING_QP)) { |
| // First we retrieve Quoted-Printable String from vCard entry, which may include |
| // multiple lines. |
| final String quotedPrintablePart = getQuotedPrintablePart(propertyRawValue); |
| |
| // "Raw value" from the view of users should contain all part of QP string. |
| // TODO: add test for this handling |
| property.setRawValue(quotedPrintablePart); |
| |
| // We split Quoted-Printable String using semi-colon before decoding it, as |
| // the Quoted-Printable may have semi-colon, which confuses splitter. |
| final List<String> quotedPrintableValueList = |
| VCardUtils.constructListFromValue(quotedPrintablePart, getVersion()); |
| for (String quotedPrintableValue : quotedPrintableValueList) { |
| String encoded = VCardUtils.parseQuotedPrintable(quotedPrintableValue, |
| false, sourceCharset, targetCharset); |
| encodedValueList.add(encoded); |
| } |
| } else { |
| final String propertyValue = getPotentialMultiline(propertyRawValue); |
| final List<String> rawValueList = |
| VCardUtils.constructListFromValue(propertyValue, getVersion()); |
| for (String rawValue : rawValueList) { |
| encodedValueList.add(VCardUtils.convertStringCharset( |
| rawValue, sourceCharset, targetCharset)); |
| } |
| } |
| |
| property.setValues(encodedValueList); |
| for (VCardInterpreter interpreter : mInterpreterList) { |
| interpreter.onPropertyCreated(property); |
| } |
| } |
| |
| /** |
| * <p> |
| * Parses and returns Quoted-Printable. |
| * </p> |
| * |
| * @param firstString The string following a parameter name and attributes. |
| * Example: "string" in |
| * "ADR:ENCODING=QUOTED-PRINTABLE:string\n\r". |
| * @return whole Quoted-Printable string, including a given argument and |
| * following lines. Excludes the last empty line following to Quoted |
| * Printable lines. |
| * @throws IOException |
| * @throws VCardException |
| */ |
| private String getQuotedPrintablePart(String firstString) |
| throws IOException, VCardException { |
| // Specifically, there may be some padding between = and CRLF. |
| // See the following: |
| // |
| // qp-line := *(qp-segment transport-padding CRLF) |
| // qp-part transport-padding |
| // qp-segment := qp-section *(SPACE / TAB) "=" |
| // ; Maximum length of 76 characters |
| // |
| // e.g. (from RFC 2045) |
| // Now's the time = |
| // for all folk to come= |
| // to the aid of their country. |
| if (firstString.trim().endsWith("=")) { |
| // remove "transport-padding" |
| int pos = firstString.length() - 1; |
| while (firstString.charAt(pos) != '=') { |
| } |
| StringBuilder builder = new StringBuilder(); |
| builder.append(firstString.substring(0, pos + 1)); |
| builder.append("\r\n"); |
| String line; |
| while (true) { |
| line = getLine(); |
| if (line == null) { |
| throw new VCardException("File ended during parsing a Quoted-Printable String"); |
| } |
| if (line.trim().endsWith("=")) { |
| // remove "transport-padding" |
| pos = line.length() - 1; |
| while (line.charAt(pos) != '=') { |
| } |
| builder.append(line.substring(0, pos + 1)); |
| builder.append("\r\n"); |
| } else { |
| builder.append(line); |
| break; |
| } |
| } |
| return builder.toString(); |
| } else { |
| return firstString; |
| } |
| } |
| |
| /** |
| * Given the first line of a property, checks consecutive lines after it and builds a new |
| * multi-line value if it exists. |
| * |
| * @param firstString The first line of the property. |
| * @return A new property, potentially built from multiple lines. |
| * @throws IOException |
| */ |
| private String getPotentialMultiline(String firstString) throws IOException { |
| final StringBuilder builder = new StringBuilder(); |
| builder.append(firstString); |
| |
| while (true) { |
| final String line = peekLine(); |
| if (line == null || line.length() == 0) { |
| break; |
| } |
| |
| final String propertyName = getPropertyNameUpperCase(line); |
| if (propertyName != null) { |
| break; |
| } |
| |
| // vCard 2.1 does not allow multi-line of adr but microsoft vcards may have it. |
| // We will consider the next line to be a part of a multi-line value if it does not |
| // contain a property name (i.e. a colon or semi-colon). |
| // Consume the line. |
| getLine(); |
| builder.append(" ").append(line); |
| } |
| |
| return builder.toString(); |
| } |
| |
| protected String getBase64(String firstString) throws IOException, VCardException { |
| final StringBuilder builder = new StringBuilder(); |
| builder.append(firstString); |
| |
| while (true) { |
| final String line = peekLine(); |
| if (line == null) { |
| throw new VCardException("File ended during parsing BASE64 binary"); |
| } |
| |
| // vCard 2.1 requires two spaces at the end of BASE64 strings, but some vCard doesn't |
| // have them. We try to detect those cases using colon and semi-colon, given BASE64 |
| // does not contain it. |
| // E.g. |
| // TEL;TYPE=WORK:+5555555 |
| // or |
| // END:VCARD |
| String propertyName = getPropertyNameUpperCase(line); |
| if (getKnownPropertyNameSet().contains(propertyName) || |
| VCardConstants.PROPERTY_X_ANDROID_CUSTOM.equals(propertyName)) { |
| Log.w(LOG_TAG, "Found a next property during parsing a BASE64 string, " + |
| "which must not contain semi-colon or colon. Treat the line as next " |
| + "property."); |
| Log.w(LOG_TAG, "Problematic line: " + line.trim()); |
| break; |
| } |
| |
| // Consume the line. |
| getLine(); |
| |
| if (line.length() == 0) { |
| break; |
| } |
| // Trim off any extraneous whitespace to handle 2.1 implementations |
| // that use 3.0 style line continuations. This is safe because space |
| // isn't a Base64 encoding value. |
| builder.append(line.trim()); |
| } |
| |
| return builder.toString(); |
| } |
| |
| /** |
| * Extracts the property name portion of a given vCard line. |
| * <p> |
| * Properties must contain a colon. |
| * <p> |
| * E.g. |
| * TEL;TYPE=WORK:+5555555 // returns "TEL" |
| * END:VCARD // returns "END" |
| * TEL; // returns null |
| * |
| * @param line The vCard line. |
| * @return The property name portion. {@literal null} if no property name found. |
| */ |
| private String getPropertyNameUpperCase(String line) { |
| final int colonIndex = line.indexOf(":"); |
| if (colonIndex > -1) { |
| final int semiColonIndex = line.indexOf(";"); |
| |
| // Find the minimum index that is greater than -1. |
| final int minIndex; |
| if (colonIndex == -1) { |
| minIndex = semiColonIndex; |
| } else if (semiColonIndex == -1) { |
| minIndex = colonIndex; |
| } else { |
| minIndex = Math.min(colonIndex, semiColonIndex); |
| } |
| return line.substring(0, minIndex).toUpperCase(); |
| } |
| return null; |
| } |
| |
| /* |
| * vCard 2.1 specifies AGENT allows one vcard entry. Currently we emit an |
| * error toward the AGENT property. |
| * // TODO: Support AGENT property. |
| * item = |
| * ... / [groups "."] "AGENT" [params] ":" vcard CRLF vcard = "BEGIN" [ws] |
| * ":" [ws] "VCARD" [ws] 1*CRLF items *CRLF "END" [ws] ":" [ws] "VCARD" |
| */ |
| protected void handleAgent(final VCardProperty property) throws VCardException { |
| if (!property.getRawValue().toUpperCase().contains("BEGIN:VCARD")) { |
| // Apparently invalid line seen in Windows Mobile 6.5. Ignore them. |
| for (VCardInterpreter interpreter : mInterpreterList) { |
| interpreter.onPropertyCreated(property); |
| } |
| return; |
| } else { |
| throw new VCardAgentNotSupportedException("AGENT Property is not supported now."); |
| } |
| } |
| |
| /** |
| * For vCard 3.0. |
| */ |
| protected String maybeUnescapeText(final String text) { |
| return text; |
| } |
| |
| /** |
| * Returns unescaped String if the character should be unescaped. Return |
| * null otherwise. e.g. In vCard 2.1, "\;" should be unescaped into ";" |
| * while "\x" should not be. |
| */ |
| protected String maybeUnescapeCharacter(final char ch) { |
| return unescapeCharacter(ch); |
| } |
| |
| /* package */ static String unescapeCharacter(final char ch) { |
| // Original vCard 2.1 specification does not allow transformation |
| // "\:" -> ":", "\," -> ",", and "\\" -> "\", but previous |
| // implementation of |
| // this class allowed them, so keep it as is. |
| if (ch == '\\' || ch == ';' || ch == ':' || ch == ',') { |
| return String.valueOf(ch); |
| } else { |
| return null; |
| } |
| } |
| |
| /** |
| * @return {@link VCardConfig#VERSION_21} |
| */ |
| protected int getVersion() { |
| return VCardConfig.VERSION_21; |
| } |
| |
| /** |
| * @return {@link VCardConfig#VERSION_30} |
| */ |
| protected String getVersionString() { |
| return VCardConstants.VERSION_V21; |
| } |
| |
| protected Set<String> getKnownPropertyNameSet() { |
| return VCardParser_V21.sKnownPropertyNameSet; |
| } |
| |
| protected Set<String> getKnownTypeSet() { |
| return VCardParser_V21.sKnownTypeSet; |
| } |
| |
| protected Set<String> getKnownValueSet() { |
| return VCardParser_V21.sKnownValueSet; |
| } |
| |
| protected Set<String> getAvailableEncodingSet() { |
| return VCardParser_V21.sAvailableEncoding; |
| } |
| |
| protected String getDefaultEncoding() { |
| return DEFAULT_ENCODING; |
| } |
| |
| protected String getDefaultCharset() { |
| return DEFAULT_CHARSET; |
| } |
| |
| protected String getCurrentCharset() { |
| return mCurrentCharset; |
| } |
| |
| public void addInterpreter(VCardInterpreter interpreter) { |
| mInterpreterList.add(interpreter); |
| } |
| |
| public void parse(InputStream is) throws IOException, VCardException { |
| if (is == null) { |
| throw new NullPointerException("InputStream must not be null."); |
| } |
| |
| final InputStreamReader tmpReader = new InputStreamReader(is, mIntermediateCharset); |
| mReader = new CustomBufferedReader(tmpReader); |
| |
| final long start = System.currentTimeMillis(); |
| for (VCardInterpreter interpreter : mInterpreterList) { |
| interpreter.onVCardStarted(); |
| } |
| |
| // vcard_file = [wsls] vcard [wsls] |
| while (true) { |
| synchronized (this) { |
| if (mCanceled) { |
| Log.i(LOG_TAG, "Cancel request has come. exitting parse operation."); |
| break; |
| } |
| } |
| if (!parseOneVCard()) { |
| break; |
| } |
| } |
| |
| for (VCardInterpreter interpreter : mInterpreterList) { |
| interpreter.onVCardEnded(); |
| } |
| } |
| |
| public void parseOne(InputStream is) throws IOException, VCardException { |
| if (is == null) { |
| throw new NullPointerException("InputStream must not be null."); |
| } |
| |
| final InputStreamReader tmpReader = new InputStreamReader(is, mIntermediateCharset); |
| mReader = new CustomBufferedReader(tmpReader); |
| |
| final long start = System.currentTimeMillis(); |
| for (VCardInterpreter interpreter : mInterpreterList) { |
| interpreter.onVCardStarted(); |
| } |
| parseOneVCard(); |
| for (VCardInterpreter interpreter : mInterpreterList) { |
| interpreter.onVCardEnded(); |
| } |
| } |
| |
| public final synchronized void cancel() { |
| Log.i(LOG_TAG, "ParserImpl received cancel operation."); |
| mCanceled = true; |
| } |
| } |
