android里Filter的研究

浏览数：28 / 时间：2015年06月11日

一、概述：

过滤器通过过滤模式来约束数据，过滤操作是通过调用filter(CharSequence)或者filter(CharSequence, android.widget.Filter.FilterListener)这些异步方法来完成的。以上方法一旦被调用，过滤请求就会被递交到请求队列中等待处理，同时该操作会取消那些之前递交的但是还没有被处理的请求。

其工作过程可以简单理解为：有一个工作队列在处理任务，但每次只能处理一个任务。每次提交一个任务的时候，如果工作队列中没有正在执行的任务，则立马执行该任务。如果有执行的任务，则该任务等待。如果队列中有正在执行的任务，并且有等待的任务，则取消所有等待的任务，把该任务放入等待的过程中。所以在任何时候，最多只能有一个任务在执行，一个任务在等待。

二、主要方法：

public void final filter(CharSequence constraint, FilterListener listener);

执行一个异步的过滤操作请求。

protected abstract FilterResults performFiltering(CharSequence constraint)；

根据约束条件调用一个工作线程来过滤数据，子类必须实现该方法来执行过滤操作。过滤结果以Filter.FilterResults的形式返回，然后在UI线程中通过publishResults(CharSequence, android.widget.Filter.FilterResults)方法来发布。

protected abstract void publishResults(CharSequence constraint, FilterResults results);

通过调用UI线程在用户界面发布过滤结果。

三、实现原理：

在一个新开的工作线程里执行过滤的操作，过滤的结果在UI线程里publish。

1.在Filter类里使用了2个Handler：RequestHandler是用来处理过滤操作的，ResultHandler是用来发布过滤结果的。

private Handler mThreadHandler;

private Handler mResultHandler;

public Filter() {

mResultHandler = new ResultHandler();

}

可见，ResultHandler在构造方法里创建，一般说来是与UI线程进行绑定的，最后过滤出结果后，publishResults是通过ResultHandler来进行分发消息的，所以最后的回调过程是在UI线程执行的，这里实现的很巧妙，可以学习之。

疑问：如果Filter类是在一个子线程里进行创建的，则在publishResults时，就不是在UI线程里执行了？实际结果是，如果在子线程里 new一个Filter对象，则会直接报错，原因是子线程里还没有构造Looper对象，需要在new Handler()之前调用Looper.prepare()方法。

2.filter请求流程。

public final void filter(CharSequence constraint, FilterListener listener) {

synchronized (mLock) {

if (mThreadHandler == null) {

HandlerThread thread = new HandlerThread(THREAD_NAME, android.os.Process.THREAD_PRIORITY_BACKGROUND);

thread.start();

mThreadHandler = new RequestHandler(thread.getLooper());

}

final long delay = (mDelayer == null) ? 0 : mDelayer.getPostingDelay(constraint);

Message message = mThreadHandler.obtainMessage(FILTER_TOKEN);

RequestArguments args = new RequestArguments();

// make sure we use an immutable copy of the constraint, so that

// it doesn‘t change while the filter operation is in progress

args.constraint = constraint != null ? constraint.toString() : null;

args.listener = listener;

message.obj = args;

mThreadHandler.removeMessages(FILTER_TOKEN);

mThreadHandler.removeMessages(FINISH_TOKEN);

mThreadHandler.sendMessageDelayed(message, delay);

}

可以看到，在这里才会创建一个HandlerThread对象，这是一个子线程，随后会创建一个RequestHandler，该Handler会与该子线程绑定。以后所有的过滤请求，都通过RequestHandler进行分发，所有的过滤操作，都会在子线程中执行。

在发起本次请求之前，会通过RequestHandler取消掉所有还未执行的消息。

再看一下RequestHandler的内部实现，

case FILTER_TOKEN: //这里处理过滤请求

RequestArguments args = (RequestArguments) msg.obj;

try {

args.results = performFiltering(args.constraint);

} catch (Exception e) {

args.results = new FilterResults();

Log.w(LOG_TAG, "An exception occured during performFiltering()!", e);

} finally {

message = mResultHandler.obtainMessage(what);

message.obj = args;

message.sendToTarget();

}

//在这里可以看到，会调用performFiltering()方法进行过滤，接着会通过ResultHandler进行结果发布。

synchronized (mLock) {

if (mThreadHandler != null) {

Message finishMessage = mThreadHandler.obtainMessage(FINISH_TOKEN);

mThreadHandler.sendMessageDelayed(finishMessage, 3000);

}

//在所有操作执行完毕后，会延迟3秒发送一个结束的消息，该消息会终止掉HandlerThread线程里的消息循环。这个地方很巧妙：1.如果连续的发起过滤请求，则会一直使用之前创建的HandlerThread线程来处理过滤操作，不会频繁的创建线程，过多的损耗性能；2.如果长时间没有过滤请求，比如超过3s后，则会终止点该线程，因为该线程实际上是个空闲的线程，可以终止掉，同样的减少性能损耗。注意要加锁操作。

break;

case FINISH_TOKEN: //这里处理终止线程的操作

synchronized (mLock) {

if (mThreadHandler != null) {

mThreadHandler.getLooper().quit();

mThreadHandler = null;

}

break;

四、总结：

1.巧妙的使用了HandlerThread来创建一个带Looper的Thread。

2.通过与不同线程绑定的Handler，来实现异步的过滤查询操作。

3.类似AutoCompleteTextView的实现，通过Filter来实现。