• 什么是 landlord_client
• 效果图
• 自定义 view
  • CircleImageView
  • CardsPack
    • adapter
    • 使用
• 网络库
  • 使用
  • 流程分析
• 游戏逻辑
• 与后端的协议适配

这是一个斗地主游戏的 Android 前端 demo，对应landlord_go后端。

特点

• 使用原生 socket+protobuf 与后端通信，轻便简捷。
• 牌桌采用自定义 view 设计，更加简洁（不会套壳）。
• 个人写前端没什么设计天赋，页面比较挫。。

效果图

自定义 view

CircleImageView

看这里

CardsPack

继承自 recyclerview。

adapter

其中持有一个 CardsPackAdapter，CardsPackAdapter 持有两个 list 代表持有的牌和打出去的牌，牌在点击后从持有的牌中删除并添加到打出去的牌中。

使用

在 GameActivity 中，首先初始化 LinearLayoutManager：

LinearLayoutManager layoutManagerLeft = new LinearLayoutManager(this, LinearLayoutManager.HORIZONTAL,
false);
layoutManagerLeft.setSmoothScrollbarEnabled(false);

然后将 LinearLayoutManager 和传递数据和标记位的 CardsPackAdapter 传递进 CardsPack 实例中：

rivalLeftCardsOut.setLayoutManager(layoutManagerLeft);
leftAdapter = rivalLeftCardsOut.new CardsPackAdapter(this, 1, leftCardsOut);
rivalLeftCardsOut.setAdapter(leftAdapter);

网络库

网络库在OkSocket的基础上进行了修改。

使用

ConnectionInfo loginInfo = new ConnectionInfo(Constants.loginHost, Constants.loginPort);
loginManager = OkSocket.open(loginInfo);
loginManager.registerReceiver(new LoginHandler());
loginManager.connect();

ConnectionInfo 用来存放 ip 和 port，调用 OkSocket.open()返回一个 IConnectionManager 实例，调用 registerReceiver()传入连接后的回调 handler 实例，最后调用 connect()进行 socket 的连接。

• LoginHandler

这是一个 SocketActionAdapter 的实现类，SocketActionAdapter 的实现类会在 socket 返回信息后分发时逐个遍历，因此可以有多个 SocketActionAdapter 的实现类去实现相同的方法，他们都会被调用。

流程分析

OkSocket.open(info)

返回一个 IConnectionManager 实例，该实例以 info 为 key 存入一个 map 缓存，第一次调用的时候调用 new ConnectionManagerImpl(info)。ConnectionManagerImpl 构造器中设置了一些标记位，提取了 ip 和 port。

ConnectionManagerImpl.connect()

1. 绑定 ActionHandler 实例

ActionHandler 实现了 SocketActionAdapter 的三个方法，被存入在一个列表中，在读写线程解析完数据后会使用这个列表来遍历处理数据。如何选择不同的方法来处理不同情况下的数据，就是靠的 key 了，其实现在 ActionDispatcher。 这里的 ActionHandler 主要处理 IOThread 启动、断开，连接失败。

1. 绑定 DefaultReconnectManager 实例

DefaultReconnectManager 同样实现了 ISocketActionListener，也算是 handler 的一种。 在 attach 方法中，持有传入的 mConnectionManager，以及其中的 mPulseManager（这个时候可能是空的，但是过几毫秒就不是空的了），将 DefaultReconnectManager 实例也传入到 ISocketActionListener 列表中。DefaultReconnectManager 实现了 ISocketActionListener 的三个方法，主要实现了断线重连的逻辑。

1. 生成 ConnectionManagerImpl.ConnectionThread 实例，并 Start

其中，socket 实例连接指定地址并设置超时，然后生成 PulseManager 实例，生成 IOThreadManager 实例并 startEngine()。连接成功就发送 action_connection_success，抛异常则发送 action_connection_failed 和异常实例。

1. 生成 PulseManager 实例

上面生成了 PulseManager 的实例，其 pulse()需要你在设置 mSendable 后自己手动调用。 在 pulse()中，设置好心跳频率后，开启 mPulseThread，其线程模式是 DUPLEX。run()中，超时了就断开，否则就发送心跳包，发送的动作是通过 IConnectionManager 实现的。 心跳是在一个线程中定期调用 ConnectionManagerImpl 的 send 方法实现的。

1. IOThreadManager.startEngine()

IOThreadManager 的构造器持有 socket 的两个流，以及 mActionDispatcher。然后获取 mReaderProtocol，也就是 ltv 协议三个部分长度的解析方法。初始化 ReaderImpl 和 WriterImpl。 startEngine()中生成 DuplexWriteThread 和 DuplexReadThread 实例，然后启动。

1. DuplexWriteThread 和 DuplexReadThread

就是装包和拆包的过程，无限执行 WriterImpl 和 ReaderImpl 的 write()和 read()。

IConnectionManager.send()

调用 IOThreadManager 的 send()，向 WriteImpl 的 LinkedBlockingQueue 中添加消息，WriteImpl 的 write()则会不停的从 LinkedBlockingQueue 中取消息处理。

这里增加了一个 sendAfterConnect()，用一个信号量控制在 connect()中的逻辑执行完后再异步的调用 send()

ReaderImpl.read()

从 socket 的 inputStream 中读取流数据后，拆包填充 OriginalData，调用 mStateSender.sendBroadcast(IOAction.ACTION_READ_COMPLETE, originalData) 进行分发，这里的 mStateSender 就是 ActionDispatcher。 ActionDispatcher 的 sendBroadcast()中将 action 和 originalData 存入 ActionDispatcher.ActionBean 实例，然后存入 LinkedBlockingQueue 中 ActionDispatcher 中的 DispatchThread 静态实例启动，其 run()中从 LinkedBlockingQueue 取出 ActionBean 实例，然后遍历 ActionDispatcher 的 mResponseHandlerList（就是上面封装的 ISocketActionListener 列表）

ActionDispatcher.dispatchActionToListener()

"action_read_complete"：ReaderImpl.read()解析成功后发送 "action_read_thread_start"：DuplexReadThread 的 beforeLoop() "action_write_thread_start"：DuplexWriteThread 的 beforeLoop() "action_read_thread_shutdown"：DuplexReadThread 的 loopFinish() "action_write_thread_shutdown":DuplexWriteThread 的 loopFinish() "action_pulse_request"：WriterImpl 的 write() "action_write_complete"：WriterImpl 的 write() "action_disconnection"：DisconnectThread 运行完之后 "action_connection_success"：ConnectionThread 连接成功 "action_connection_failed"：ConnectionThread 连接失败抛出异常

游戏逻辑

1. 进入房间后准备

准备：发送 new ReadyRequest(true)

解除整备：发送 new CancelReadyRequest(true)

所有玩家准备后开始抢地主

1. 开始抢地主

onGrabLandlordResponse()中显示三张地主牌，显示手中的牌，显示抢地主面板

选择抢地主：选择加倍

选择不抢地主：顺移到右边的玩家抢地主，如果其他两个玩家都不抢地主，强制成为地主，选择加倍

1. 选择加倍

onEndGrabLandlordResponse()中地主显示加倍选择面板，在地主选择加倍后其他两个玩家选择加倍应答面板

不选择加倍：直接开始游戏

选择加倍：其他玩家根据倍数判断是否加倍，有一个人不同意加倍，则加倍取消，开始游戏

1. 开始游戏

onCardsOutResponse()中出牌和接牌

对牌的判断和处理逻辑都在前端

第一个牌出完的玩家触发结束游戏

1. 结束游戏

onEndGameResponse()中弹窗显示战绩，你可以选择继续也可以选择退出房间

与后端的协议适配

后端的拆包和封包协议都采用的是 ltv 格式，length-type-value。内容长度如下：

public class ReaderProtocol1 implements IReaderProtocol {
    @Override
    public int getHeaderLength() {
        return 2;
    }

    @Override
    public int getTypeLength() {
        return 2;
    }

    @Override
    public int getBodyLength(byte[] header, ByteOrder byteOrder) {
        if (header == null || header.length < getHeaderLength()) {
            return 0;
        }
        ByteBuffer bb = ByteBuffer.wrap(header);
        bb.order(byteOrder);
        return bb.getShort() - 2;
    }
}

封包示例

public class JsonReq implements ISendable {
    private int jsonType;
    private byte[] content;

    public JsonReq(int jsonType, byte[] content) {
        this.jsonType = jsonType;
        this.content = content;
    }

    public int getJsonType() {
        return jsonType;
    }

    public byte[] getContent() {
        return content;
    }

    @Override
    public byte[] parse() {
        Landlord.JsonREQ.Builder builder = Landlord.JsonREQ.newBuilder();
        builder.setJsonType(jsonType);
        builder.setContent(ByteString.copyFrom(content));
        Landlord.JsonREQ req = builder.build();
        byte[] body = req.toByteArray();
        ByteBuffer bb = ByteBuffer.allocate(4+body.length);
        bb.order(ByteOrder.LITTLE_ENDIAN);
        bb.putShort((short)(body.length+2));
        bb.putShort(Constants.JSON_REQ_TYPE);
        bb.put(body);
        return bb.array();
    }
}

特别注意：后端采用的是小端序列，因此前端也要用小端序列，而 Java 默认的是大端序列。