[Android]为TextView提供双色文本配置的小工具ColorPhrase

本文链接http://blog.csdn.net/jan_s/article/details/51338944，转载请留言。

在安卓开发过程中，经常会看到文本中有重点的字段是需要换色的，为了表现其特殊性。这个时候大多数人都会用比较简单的方式就是再New 一个TextView出来，显然很快速，然而这样做无疑是给布局绘制添加麻烦，这里简单提供一个工具ColorPhrase类，帮你解决这一的麻烦。

先看demo效果图

、

使用方式：

1.MainActivity.java

public class MainActivity extends Activity {
	private EditText editText;
	private TextView textView;
	private Button button;
	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);
		editText = (EditText) findViewById(R.id.editText1);
		textView = (TextView) findViewById(R.id.textView1);
		button = (Button) findViewById(R.id.button1);
		button.setOnClickListener(new OnClickListener() {
			
			@Override
			public void onClick(View v) {
				//这里是使用方法：将主要换色的文本用“{}”区分出来，然后对其文本风格颜色做处理，这就是ColorPhrase的工作了。
				String pattern = editText.getText().toString();
				CharSequence chars = ColorPhrase.from(pattern).withSeparator("{}").innerColor(getResources().getColor(R.color.in_color)).outerColor(getResources().getColor(R.color.out_color)).format();
				textView.setText(chars);
			}
		});
	}
}

2.ColorPhrase.java-这是主要的功能实现类，拷贝到项目中即可。

public class ColorPhrase {
	/** The unmodified original pattern. */
	private final CharSequence pattern;
	/** Cached result after replacing all keys with corresponding values. */
	private CharSequence formatted;
	/**
	 * The constructor parses the original pattern into this doubly-linked list
	 * of tokens.
	 */
	private Token head;

	/** When parsing, this is the current character. */
	private char curChar;
	private String separator;// default "{}"
	private int curCharIndex;
	private int outerColor;// color that outside the separators,default 0xFF666666
	private int innerColor;// color that between the separators,default 0xFFA6454A
	/** Indicates parsing is complete. */
	private static final int EOF = 0;

	/**
	 * Entry point into this API.
	 * 
	 * @throws IllegalArgumentException
	 *             if pattern contains any syntax errors.
	 */
	@TargetApi(Build.VERSION_CODES.HONEYCOMB)
	public static ColorPhrase from(Fragment f, int patternResourceId) {
		return from(f.getResources(), patternResourceId);
	}

	/**
	 * Entry point into this API.
	 * 
	 * @throws IllegalArgumentException
	 *             if pattern contains any syntax errors.
	 */
	public static ColorPhrase from(View v, int patternResourceId) {
		return from(v.getResources(), patternResourceId);
	}

	/**
	 * Entry point into this API.
	 * 
	 * @throws IllegalArgumentException
	 *             if pattern contains any syntax errors.
	 */
	public static ColorPhrase from(Context c, int patternResourceId) {
		return from(c.getResources(), patternResourceId);
	}

	/**
	 * Entry point into this API.
	 * 
	 * @throws IllegalArgumentException
	 *             if pattern contains any syntax errors.
	 */
	public static ColorPhrase from(Resources r, int patternResourceId) {
		return from(r.getText(patternResourceId));
	}

	/**
	 * Entry point into this API; pattern must be non-null.
	 * 
	 * @throws IllegalArgumentException
	 *             if pattern contains any syntax errors.
	 */
	public static ColorPhrase from(CharSequence pattern) {
		return new ColorPhrase(pattern);
	}

	private ColorPhrase(CharSequence pattern) {
		curChar = (pattern.length() > 0) ? pattern.charAt(0) : EOF;

		this.pattern = pattern;
		// Invalidate the cached formatted text.
		formatted = null;
		separator = "{}";// initialize the default separator
		outerColor = 0xFF666666;//initialize the default value
		innerColor =0xFFE6454A;//initialize the default value
	}

	/**
	 * set the separator of the target，called after from() method.
	 * 
	 * @param _separator
	 * @return
	 */
	public ColorPhrase withSeparator(String _separator) {
		if (TextUtils.isEmpty(_separator)) {
			throw new IllegalArgumentException("separator must not be empty!");
		}
		if (_separator.length() > 2) {
			throw new IllegalArgumentException("separator‘s length must not be more than 3 charactors!");
		}
		this.separator = _separator;
		return this;
	}

	/**
	 * init the outerColor
	 * 
	 * @param _outerColor
	 * @return
	 */
	public ColorPhrase outerColor(int _outerColor) {
		this.outerColor = _outerColor;
		return this;
	}

	/**
	 * init the innerColor
	 * 
	 * @param _innerColor
	 * @return
	 */
	public ColorPhrase innerColor(int _innerColor) {
		this.innerColor = _innerColor;
		return this;
	}

	/**
	 * cut the pattern with the separators and linked them with double link
	 * structure;
	 */
	private void createDoubleLinkWithToken() {
		// A hand-coded lexer based on the idioms in
		// "Building Recognizers By Hand".
		// http://www.antlr2.org/book/byhand.pdf.
		Token prev = null;
		Token next;
		while ((next = token(prev)) != null) {
			// Creates a doubly-linked list of tokens starting with head.
			if (head == null)
				head = next;
			prev = next;
		}
	}

	/**
	 * Returns the next token from the input pattern, or null when finished
	 * parsing.
	 */
	private Token token(Token prev) {
		if (curChar == EOF) {
			return null;
		}
		if (curChar == getLeftSeparator()) {
			char nextChar = lookahead();
			if (nextChar == getLeftSeparator()) {
				return leftSeparator(prev);
			} else {
				return inner(prev);
			}
		}
		return outer(prev);
	}

	private char getLeftSeparator() {
		return separator.charAt(0);
	}

	private char getRightSeparator() {
		if (separator.length() == 2) {
			return separator.charAt(1);
		}
		return separator.charAt(0);
	}

	/**
	 * Returns the text after replacing all keys with values.
	 * 
	 * @throws IllegalArgumentException
	 *             if any keys are not replaced.
	 */
	public CharSequence format() {
		if (formatted == null) {
			if (!checkPattern()) {
				throw new IllegalStateException("the separators don't match in the pattern!");
			}
			createDoubleLinkWithToken();
			// Copy the original pattern to preserve all spans, such as bold,
			// italic, etc.
			SpannableStringBuilder sb = new SpannableStringBuilder(pattern);
			for (Token t = head; t != null; t = t.next) {
				t.expand(sb);
			}

			formatted = sb;
		}
		return formatted;
	}

	/**
	 * check if the pattern has legal separators
	 * 
	 * @return
	 */
	private boolean checkPattern() {
		if (pattern == null) {
			return false;
		}
		char leftSeparator = getLeftSeparator();
		char rightSeparator = getRightSeparator();
		Stack<Character> separatorStack = new Stack<Character>();
		for (int i = 0; i < pattern.length(); i++) {
			char cur = pattern.charAt(i);
			if (cur == leftSeparator) {
				separatorStack.push(cur);
			} else if (cur == rightSeparator) {
				if (!separatorStack.isEmpty() && (separatorStack.pop() == leftSeparator)) {
					continue;
				} else {
					return false;
				}
			}
		}
		return separatorStack.isEmpty();
	}

	private InnerToken inner(Token prev) {

		// Store keys as normal Strings; we don't want keys to contain spans.
		StringBuilder sb = new StringBuilder();

		// Consume the left separator.
		consume();
		char rightSeparator = getRightSeparator();
		while (curChar != rightSeparator && curChar != EOF) {
			sb.append(curChar);
			consume();
		}

		if (curChar == EOF) {
			throw new IllegalArgumentException("Missing closing separator");
		}
        //consume the right separator.
		consume();

		if (sb.length() == 0) {
			throw new IllegalStateException("Disallow empty content between separators,for example {}");
		}

		String key = sb.toString();
		return new InnerToken(prev, key, innerColor);
	}

	/** Consumes and returns a token for a sequence of text. */
	private OuterToken outer(Token prev) {
		int startIndex = curCharIndex;

		while (curChar != getLeftSeparator() && curChar != EOF) {
			consume();
		}
		return new OuterToken(prev, curCharIndex - startIndex, outerColor);
	}

	/**
	 * Consumes and returns a token representing two consecutive curly brackets.
	 */
	private LeftSeparatorToken leftSeparator(Token prev) {
		consume();
		consume();
		return new LeftSeparatorToken(prev, getLeftSeparator());
	}

	/** Returns the next character in the input pattern without advancing. */
	private char lookahead() {
		return curCharIndex < pattern.length() - 1 ? pattern.charAt(curCharIndex + 1) : EOF;
	}

	/**
	 * Advances the current character position without any error checking.
	 * Consuming beyond the end of the string can only happen if this parser
	 * contains a bug.
	 */
	private void consume() {
		curCharIndex++;
		curChar = (curCharIndex == pattern.length()) ? EOF : pattern.charAt(curCharIndex);
	}

	/**
	 * Returns the raw pattern without expanding keys; only useful for
	 * debugging. Does not pass through to {@link #format()} because doing so
	 * would drop all spans.
	 */
	@Override
	public String toString() {
		return pattern.toString();
	}

	private abstract static class Token {
		private final Token prev;
		private Token next;

		protected Token(Token prev) {
			this.prev = prev;
			if (prev != null)
				prev.next = this;
		}

		/** Replace text in {@code target} with this token's associated value. */
		abstract void expand(SpannableStringBuilder target);

		/** Returns the number of characters after expansion. */
		abstract int getFormattedLength();

		/** Returns the character index after expansion. */
		final int getFormattedStart() {
			if (prev == null) {
				// The first token.
				return 0;
			} else {
				// Recursively ask the predecessor node for the starting index.
				return prev.getFormattedStart() + prev.getFormattedLength();
			}
		}
	}

	/** Ordinary text between tokens. */
	private static class OuterToken extends Token {
		private final int textLength;
		private int color;

		OuterToken(Token prev, int textLength, int _color) {
			super(prev);
			this.textLength = textLength;
			this.color = _color;
		}

		@Override
		void expand(SpannableStringBuilder target) {

			int startPoint = getFormattedStart();
			int endPoint = startPoint + textLength;
			target.setSpan(new ForegroundColorSpan(color), startPoint, endPoint, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
		}

		@Override
		int getFormattedLength() {
			return textLength;
		}
	}

	/** A sequence of two curly brackets. */
	private static class LeftSeparatorToken extends Token {
		private char leftSeparetor;

		LeftSeparatorToken(Token prev, char _leftSeparator) {
			super(prev);
			leftSeparetor = _leftSeparator;
		}

		@Override
		void expand(SpannableStringBuilder target) {
			int start = getFormattedStart();
			target.replace(start, start + 2, String.valueOf(leftSeparetor));
		}

		@Override
		int getFormattedLength() {
			// for example,,Replace "{{" with "{".
			return 1;
		}
	}

	private static class InnerToken extends Token {
		/** The InnerText without separators,like '{' and '}'. */
		private final String innerText;

		private int color;

		InnerToken(Token prev, String _inner, int _color) {
			super(prev);
			this.innerText = _inner;
			color = _color;
		}

		@Override
		void expand(SpannableStringBuilder target) {

			int replaceFrom = getFormattedStart();
			// Add 2 to account for the separators.
			int replaceTo = replaceFrom + innerText.length() + 2;
			target.replace(replaceFrom, replaceTo, innerText);
			target.setSpan(new ForegroundColorSpan(color), replaceFrom, replaceTo - 2, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
		}

		@Override
		int getFormattedLength() {
			// Note that value is only present after expand. Don't error check
			// because this is all
			// private code.
			return innerText.length();
		}
	}
}

好了，需要demo的朋友请点此下载