导航菜单

页面标题

页面副标题

95爱播免登录版 v3.1.9 - AgentRoster.java 源代码

正在查看: 95爱播免登录版 v3.1.9 应用的 AgentRoster.java JAVA 源代码文件

本页面展示 JAVA 反编译生成的源代码文件,支持语法高亮显示。 仅供安全研究与技术分析使用,严禁用于任何非法用途。请遵守相关法律法规。


package org.jivesoftware.smackx.workgroup.agent;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.jivesoftware.smack.Connection;
import org.jivesoftware.smack.PacketListener;
import org.jivesoftware.smack.filter.PacketTypeFilter;
import org.jivesoftware.smack.packet.Packet;
import org.jivesoftware.smack.packet.Presence;
import org.jivesoftware.smack.util.StringUtils;
import org.jivesoftware.smackx.packet.DiscoverItems;
import org.jivesoftware.smackx.workgroup.packet.AgentStatus;
import org.jivesoftware.smackx.workgroup.packet.AgentStatusRequest;

public class AgentRoster {
    private static final int EVENT_AGENT_ADDED = 0;
    private static final int EVENT_AGENT_REMOVED = 1;
    private static final int EVENT_PRESENCE_CHANGED = 2;
    private Connection connection;
    private String workgroupJID;
    boolean rosterInitialized = false;
    private List<String> entries = new ArrayList();
    private List<AgentRosterListener> listeners = new ArrayList();
    private Map<String, Map<String, Presence>> presenceMap = new HashMap();

    private class AgentStatusListener implements PacketListener {
        private AgentStatusListener() {
        }

        public void processPacket(Packet packet) {
            if (packet instanceof AgentStatusRequest) {
                for (AgentStatusRequest.Item item : ((AgentStatusRequest) packet).getAgents()) {
                    String jid = item.getJID();
                    if (DiscoverItems.Item.REMOVE_ACTION.equals(item.getType())) {
                        AgentRoster.this.presenceMap.remove(StringUtils.parseName(String.valueOf(StringUtils.parseName(jid)) + "@" + StringUtils.parseServer(jid)));
                        AgentRoster.this.fireEvent(1, jid);
                    } else {
                        AgentRoster.this.entries.add(jid);
                        AgentRoster.this.fireEvent(0, jid);
                    }
                }
                AgentRoster.this.rosterInitialized = true;
            }
        }

        AgentStatusListener(AgentRoster agentRoster, AgentStatusListener agentStatusListener) {
            this();
        }
    }

    private class PresencePacketListener implements PacketListener {
        private PresencePacketListener() {
        }

        public void processPacket(Packet packet) {
            Map map;
            Presence presence = (Presence) packet;
            String from = presence.getFrom();
            if (from == null) {
                System.out.println("Presence with no FROM: " + presence.toXML());
                return;
            }
            String presenceMapKey = AgentRoster.this.getPresenceMapKey(from);
            if (presence.getType() != Presence.Type.available) {
                if (presence.getType() == Presence.Type.unavailable) {
                    if (AgentRoster.this.presenceMap.get(presenceMapKey) != null) {
                        Map map2 = (Map) AgentRoster.this.presenceMap.get(presenceMapKey);
                        synchronized (map2) {
                            map2.remove(StringUtils.parseResource(from));
                        }
                        if (map2.isEmpty()) {
                            AgentRoster.this.presenceMap.remove(presenceMapKey);
                        }
                    }
                    synchronized (AgentRoster.this.entries) {
                        Iterator it = AgentRoster.this.entries.iterator();
                        while (it.hasNext()) {
                            if (((String) it.next()).toLowerCase().equals(StringUtils.parseBareAddress(presenceMapKey).toLowerCase())) {
                                AgentRoster.this.fireEvent(2, packet);
                            }
                        }
                    }
                    return;
                }
                return;
            }
            AgentStatus agentStatus = (AgentStatus) presence.getExtension(AgentStatus.ELEMENT_NAME, "http://jabber.org/protocol/workgroup");
            if (agentStatus != null && AgentRoster.this.workgroupJID.equals(agentStatus.getWorkgroupJID())) {
                if (AgentRoster.this.presenceMap.get(presenceMapKey) == null) {
                    map = new HashMap();
                    AgentRoster.this.presenceMap.put(presenceMapKey, map);
                } else {
                    map = (Map) AgentRoster.this.presenceMap.get(presenceMapKey);
                }
                synchronized (map) {
                    map.put(StringUtils.parseResource(from), presence);
                }
                synchronized (AgentRoster.this.entries) {
                    Iterator it2 = AgentRoster.this.entries.iterator();
                    while (it2.hasNext()) {
                        if (((String) it2.next()).toLowerCase().equals(StringUtils.parseBareAddress(presenceMapKey).toLowerCase())) {
                            AgentRoster.this.fireEvent(2, packet);
                        }
                    }
                }
            }
        }

        PresencePacketListener(AgentRoster agentRoster, PresencePacketListener presencePacketListener) {
            this();
        }
    }

    AgentRoster(Connection connection, String str) {
        this.connection = connection;
        this.workgroupJID = str;
        connection.addPacketListener(new AgentStatusListener(this, null), new PacketTypeFilter(AgentStatusRequest.class));
        connection.addPacketListener(new PresencePacketListener(this, 0 == true ? 1 : 0), new PacketTypeFilter(Presence.class));
        AgentStatusRequest agentStatusRequest = new AgentStatusRequest();
        agentStatusRequest.setTo(str);
        connection.sendPacket(agentStatusRequest);
    }

    public void fireEvent(int i, Object obj) {
        int size;
        AgentRosterListener[] agentRosterListenerArr;
        synchronized (this.listeners) {
            size = this.listeners.size();
            agentRosterListenerArr = new AgentRosterListener[size];
            this.listeners.toArray(agentRosterListenerArr);
        }
        for (int i2 = 0; i2 < size; i2++) {
            if (i == 0) {
                agentRosterListenerArr[i2].agentAdded((String) obj);
            } else if (i == 1) {
                agentRosterListenerArr[i2].agentRemoved((String) obj);
            } else if (i == 2) {
                agentRosterListenerArr[i2].presenceChanged((Presence) obj);
            }
        }
    }

    public String getPresenceMapKey(String str) {
        return !contains(str) ? StringUtils.parseBareAddress(str).toLowerCase() : str;
    }

    public void addListener(AgentRosterListener agentRosterListener) {
        synchronized (this.listeners) {
            if (!this.listeners.contains(agentRosterListener)) {
                this.listeners.add(agentRosterListener);
                for (String str : getAgents()) {
                    if (this.entries.contains(str)) {
                        agentRosterListener.agentAdded(str);
                        Map<String, Presence> map = this.presenceMap.get(str);
                        if (map != null) {
                            Iterator<Presence> it = map.values().iterator();
                            while (it.hasNext()) {
                                agentRosterListener.presenceChanged(it.next());
                            }
                        }
                    }
                }
            }
        }
    }

    public boolean contains(String str) {
        if (str == null) {
            return false;
        }
        synchronized (this.entries) {
            Iterator<String> it = this.entries.iterator();
            while (it.hasNext()) {
                if (it.next().toLowerCase().equals(str.toLowerCase())) {
                    return true;
                }
            }
            return false;
        }
    }

    public int getAgentCount() {
        return this.entries.size();
    }

    public Set<String> getAgents() {
        HashSet hashSet = new HashSet();
        synchronized (this.entries) {
            Iterator<String> it = this.entries.iterator();
            while (it.hasNext()) {
                hashSet.add(it.next());
            }
        }
        return Collections.unmodifiableSet(hashSet);
    }

    public Presence getPresence(String str) {
        Map<String, Presence> map = this.presenceMap.get(getPresenceMapKey(str));
        if (map == null) {
            Presence presence = new Presence(Presence.Type.unavailable);
            presence.setFrom(str);
            return presence;
        }
        Iterator<String> it = map.keySet().iterator();
        Presence presence2 = null;
        while (it.hasNext()) {
            Presence presence3 = map.get(it.next());
            if (presence2 == null || presence3.getPriority() > presence2.getPriority()) {
                presence2 = presence3;
            }
        }
        if (presence2 != null) {
            return presence2;
        }
        Presence presence4 = new Presence(Presence.Type.unavailable);
        presence4.setFrom(str);
        return presence4;
    }

    public void reload() {
        AgentStatusRequest agentStatusRequest = new AgentStatusRequest();
        agentStatusRequest.setTo(this.workgroupJID);
        this.connection.sendPacket(agentStatusRequest);
    }

    public void removeListener(AgentRosterListener agentRosterListener) {
        synchronized (this.listeners) {
            this.listeners.remove(agentRosterListener);
        }
    }
}