维护用户在线状态

package io.agora;

import java.util.HashMap;
import java.util.Timer;
import java.util.TimerTask;
import java.util.logging.Logger;


public class UserRegistry {
    public static int EVENT_BROADCASTER_JOIN = 103;
    public static int EVENT_BROADCASTER_QUIT = 104;
    public static int EVENT_AUDIENCE_JOIN = 105;
    public static int EVENT_AUDIENCE_QUIT = 106;
    public static int EVENT_CHANGE_ROLE_TO_BROADCASTER = 111;
    public static int EVENT_CHANGE_ROLE_TO_AUDIENCE = 112;
    public static int ROLE_BROADCASTER = 1;
    public static int ROLE_AUDIENCE = 2;
    public static int WAIT_TIMEOUT_MS = 60 * 1000;

    private static Logger logger = Logger.getLogger("UserRegistry");
    private Timer timer;

    // 定义每个用户的数据结构，包括用户 ID、用户角色、用户是否在频道内、已处理的最后一个事件的序列号
    class User {
        int uid;
        int role;
        boolean isOnline;
        long lastClientSeq;

        public User(int uid, int role, boolean isOnline, long clientSeq) {
            this.uid = uid;
            this.role = role;
            this.isOnline = isOnline;
            this.lastClientSeq = clientSeq;
        }
    };

    // 定义频道列表和每个频道中的用户列表
    class Channel {
        HashMap<Integer, User> users = new HashMap<>();
    };

    private HashMap<String, Channel> channels;

    // 处理声网消息通知服务发送的频道事件回调
    public void HandleNcsEvent(String cname, int uid, int eventType, long clientSeq) {
        // 判断收到的事件类型是否需要处理。如果不是，则丢弃；如果是，则进行以下处理：
        if (eventType != EVENT_BROADCASTER_JOIN &&
                eventType != EVENT_BROADCASTER_QUIT &&
                eventType != EVENT_AUDIENCE_JOIN &&
                eventType != EVENT_AUDIENCE_QUIT &&
                eventType != EVENT_CHANGE_ROLE_TO_BROADCASTER &&
                eventType != EVENT_CHANGE_ROLE_TO_AUDIENCE) {
            logger.warning("Drop un-expected NCS event type " + eventType);
            return;
        }
        // 判断是否为用户上线事件
        boolean isOnlineInNotice = IsUserOnlineInNotice(eventType);
        // 根据事件类型判断用户角色
        int roleInNotice = GetUserRoleInNotice(eventType);

        Channel channel = channels.get(cname);
        if (channel == null) {
            // 如果频道不存在，则创建频道
            channel = new Channel();
            channels.put(cname, channel);
            logger.info("New channel " + cname + " created");
        }

        User user = channel.users.get(uid);
        // 获取用户是否离开频道
        boolean isQuit = !isOnlineInNotice && (user == null || user.isOnline);

        if (user == null) {
            // 如果用户不存在，则创建该用户的数据结构，并添加到对应频道的用户列表中
            user = new User(uid, roleInNotice, isOnlineInNotice, clientSeq);
            channel.users.put(uid, user);
            if (!isOnlineInNotice) {
                logger.info("New User " + uid + " joined");
            } else {
                // 缓存用户离开状态，并启动定时器
                DelayedRemoveUserFromChannel(cname, uid, clientSeq);
            }
        } else if (clientSeq > user.lastClientSeq) {
            // 如果用户已经存在，对比当前事件的 clientSeq 和已处理的该用户的上一个事件的 clientSeq
            // 如果当前事件的 clientSeq 较大，则根据当前事件更新该用户的数据结构；否则，不处理该事件
            user.role = roleInNotice;
            user.isOnline = isOnlineInNotice;
            user.lastClientSeq = clientSeq;
            if (isQuit) {
                // 标记用户已下线，等待一段时间后删除该用户的数据
                logger.info("User " + uid + " quit channel " + cname);
                DelayedRemoveUserFromChannel(cname, uid, clientSeq);
            }
        }
    }

    // 启动定时器并删除离线用户
    private void DelayedRemoveUserFromChannel(final String cname, final int uid, final long clientSeq) {
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                Channel channel = channels.get(cname);
                if (channel == null) return;
                User user = channel.users.get(uid);
                if (user == null) return;
                // 如果 clientSeq 有变化，则不做删除处理
                if (user.lastClientSeq != clientSeq) return;
                if (!user.isOnline) {
                    // 当且仅当用户状态仍然是离线时删除用户，且 clientSeq 没有变化才进行清理
                    channel.users.remove(uid);
                    logger.info("Remove user " + uid + " from channel " + cname);
                } else {
                    logger.info("User " + uid + " is online while delayed removing, cancelled");
                }
                if (channel.users.isEmpty()) {
                    channels.remove(cname);
                    logger.info("Remove channel " + cname);
                }
            }
        }, WAIT_TIMEOUT_MS);
    }

    // 判断是否为用户上线事件
    private static boolean IsUserOnlineInNotice(int eventType) {
        return eventType == EVENT_BROADCASTER_JOIN ||
                eventType == EVENT_AUDIENCE_JOIN ||
                eventType == EVENT_CHANGE_ROLE_TO_BROADCASTER ||
                eventType == EVENT_CHANGE_ROLE_TO_AUDIENCE;
    }

    // 判断用户角色
    private static int GetUserRoleInNotice(int eventType) {
        if (eventType == EVENT_BROADCASTER_JOIN ||
                eventType == EVENT_BROADCASTER_QUIT ||
                eventType == EVENT_CHANGE_ROLE_TO_BROADCASTER) {
            return ROLE_BROADCASTER;
        } else {
            return ROLE_AUDIENCE;
        }
    }
}