基于XMPP协议的aSmack源码分析【3】register过程分析

register过程分析
RegisterTask这个task在运行中，添加了一个监听，上面说道的PacketReader中有一个消息机制，在不停的解析服务器返回的结果，然后将解析过后的包分发给各个监听器（观察者），而register中就注册了一个监听器，比较有意思的是，监听器被注册时还加了一个过滤器，这个过滤器的目的是监听器只接收自己感兴趣的内容，这个设计真的很赞。这样就不必在数据源头PacketReader中对数据进行过滤了，只要后期扩展自己Packet和自己的过滤器，就能达到排除自己不关心的信息的功能。

1 Registration registration = new Registration();
2
3                 PacketFilter packetFilter = new AndFilter(new PacketIDFilter(
4                         registration.getPacketID()), new PacketTypeFilter(
5                         IQ.class));

其中Registration的类型其实一个IQ的子类，IQ是Packet的子类。
AndFilter是PacketFilter的子类，PacketFilter的种类型有很多，也可以自己扩展，AndFilter就是其中一个、PacketTypeFilter也是、PacketIDFilter也是，
其中PacketTypeFilter的构造方法传入一个IQ.class，其实就是通过这个类文件来过滤packet，这个PacketTypeFilter就是要设置关心的Packet，这里面它告诉监听器，只接收类型为IQ的Packet，这些Filter中都有一个关键方法，accept(Packet packet).这个accept方法每个Filter的实现方式都不一样，我们可可以扩展自己的Filter并且重写这个方法，最有意思的是AndFilter这个类，他的构造方法传入的是一个动态数组，类型为PacketFilter，你可以传入你需要的过滤器，将他们当成组合条件使用来过滤Packet，这个就是典型的装饰设计模式和职责链模式的组合使用。

注册监听器

PacketListener packetListener = new PacketListener() {
//这一部分就是监听器接收到Packet后执行的后续操作
public void processPacket(Packet packet) {
Log.d("RegisterTask.PacketListener",
"processPacket().....");
Log.d("RegisterTask.PacketListener", "packet="
+ packet.toXML());

if (packet instanceof IQ) {
IQ response = (IQ) packet;
if (response.getType() == IQ.Type.ERROR) {
if (!response.getError().toString().contains(
"409")) {
Log.e(LOGTAG,
"Unknown error while registering XMPP account! "
+ response.getError()
.getCondition());
}
} else if (response.getType() == IQ.Type.RESULT) {
xmppManager.setUsername(newUsername);
xmppManager.setPassword(newPassword);
Log.d(LOGTAG, "username=" + newUsername);
Log.d(LOGTAG, "password=" + newPassword);

Editor editor = sharedPrefs.edit();
editor.putString(Constants.XMPP_USERNAME,
newUsername);
editor.putString(Constants.XMPP_PASSWORD,
newPassword);
editor.commit();
Log
.i(LOGTAG,
"Account registered successfully");
//执行task
xmppManager.runTask();
}
}
}
};

connection.addPacketListener(packetListener, packetFilter);

addPacketListener方法传入一个监听器和过滤器，看一下内部

/**
* Registers a packet listener with this connection. A packet filter determines
* which packets will be delivered to the listener. If the same packet listener
* is added again with a different filter, only the new filter will be used.
*
* @param packetListener the packet listener to notify of new received packets.
* @param packetFilter   the packet filter to use.
*/
public void addPacketListener(PacketListener packetListener, PacketFilter packetFilter) {
if (packetListener == null) {
throw new NullPointerException("Packet listener is null.");
}
ListenerWrapper wrapper = new ListenerWrapper(packetListener, packetFilter);
recvListeners.put(packetListener, wrapper);
}

可以看到，监听器和过滤器被 ListenerWrapper 再次封装，后续的recvListeners这个集合将ListenerWrapper收入囊中，好整个注册过程完毕，就等待接收信息了，那么发送信息的地方在什么地方呢？分析connect过程时，上面的PacketReader中已经开始循环发送了，代码如下
listenerExecutor.submit(new ListenerNotification(packet));其中ListenerNotification是个Runnable

/**
* A runnable to notify all listeners of a packet.
*/
private class ListenerNotification implements Runnable {

private Packet packet;

public ListenerNotification(Packet packet) {
this.packet = packet;
}

4000
public void run() {
for (ListenerWrapper listenerWrapper : connection.recvListeners.values()) {
listenerWrapper.notifyListener(packet);
}
}
}

而listenerWrapper的notifyListener(packet)内部，使用了传入的过滤器对Packet进行了过滤

/**
* Notify and process the packet listener if the filter matches the packet.
*
* @param packet the packet which was sent or received.
*/
public void notifyListener(Packet packet) {
if (packetFilter == null || packetFilter.accept(packet)) {
packetListener.processPacket(packet);
}

而具体的过滤机制还是转调了传入的过滤器本身的过滤方式accept，非常的灵活。过滤完的Packet将被发送出去

这个方法connection.sendPacket(registration);将一个Registration对象发了出去，

public void sendPacket(Packet packet) {
if (!isConnected()) {
throw new IllegalStateException("Not connected to server.");
}
if (packet == null) {
throw new NullPointerException("Packet is null.");
}
packetWriter.sendPacket(packet);
}

内部转调的是 packetWriter.sendPacket(packet);以前提到过PacketWirter中有两个循环机制，其中一个就是在不停的访问队列来获取Packet，而这个sendPacket方法就是将消息写入队列中供消费者使用。

/**
* Sends the specified packet to the server.
*
* @param packet the packet to send.
*/
public void sendPacket(Packet packet) {
if (!done) {
// Invoke interceptors for the new packet that is about to be sent. Interceptors
// may modify the content of the packet.
//内部执行了一个发送数据源的动作，也是为某些监听器对象服务的interceptorWrapper.notifyListener(packet);
connection.firePacketInterceptors(packet);

try {
//将一个Packet对象放入到阻塞队列中，在上面的witerPacket方法中的wile循环中发送出去
queue.put(packet);
}
catch (InterruptedException ie) {
ie.printStackTrace();
return;
}
synchronized (queue) {
queue.notifyAll();
}

// Process packet writer listeners. Note that we're using the sending
// thread so it's expected that listeners are fast.
connection.firePacketSendingListeners(packet);
}
}

其实，注册的过程就是在注册监听，这样在有消息发出时，才可以根据业务需求对消息进行接收和处理。