曹妃甸核酸检测平台.apk(点击下载) / EntityCapsManager.java

package asmack.org.jivesoftware.smackx;

import asmack.org.jivesoftware.smack.Connection;
import asmack.org.jivesoftware.smack.PacketListener;
import asmack.org.jivesoftware.smack.filter.AndFilter;
import asmack.org.jivesoftware.smack.filter.PacketExtensionFilter;
import asmack.org.jivesoftware.smack.filter.PacketTypeFilter;
import asmack.org.jivesoftware.smack.packet.Packet;
import asmack.org.jivesoftware.smack.packet.Presence;
import asmack.org.jivesoftware.smack.provider.ProviderManager;
import asmack.org.jivesoftware.smack.util.Base64;
import asmack.org.jivesoftware.smackx.packet.CapsExtension;
import asmack.org.jivesoftware.smackx.packet.DataForm;
import asmack.org.jivesoftware.smackx.packet.DiscoverInfo;
import asmack.org.jivesoftware.smackx.provider.CapsExtensionProvider;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArraySet;

public class EntityCapsManager {
    public static final String HASH_METHOD = "sha-1";
    public static final String HASH_METHOD_CAPS = "SHA-1";
    private static Map<String, DiscoverInfo> caps = new ConcurrentHashMap();
    private static String entityNode = "http://www.igniterealtime.org/projects/smack/";
    private Set<CapsVerListener> capsVerListeners = new CopyOnWriteArraySet();
    private String currentCapsVersion = null;
    private Map<String, String> userCaps = new ConcurrentHashMap();

    /* access modifiers changed from: package-private */
    public class CapsPacketListener implements PacketListener {
        CapsPacketListener() {
        }

        @Override // asmack.org.jivesoftware.smack.PacketListener
        public void processPacket(Packet packet) {
            CapsExtension capsExtension = (CapsExtension) packet.getExtension("c", CapsExtension.XMLNS);
            EntityCapsManager.this.addUserCapsNode(packet.getFrom(), String.valueOf(capsExtension.getNode()) + "#" + capsExtension.getVersion());
        }
    }

    static {
        ProviderManager.getInstance().addExtensionProvider("c", CapsExtension.XMLNS, new CapsExtensionProvider());
    }

    public static void addDiscoverInfoByNode(String str, DiscoverInfo discoverInfo) {
        cleanupDicsoverInfo(discoverInfo);
        caps.put(str, discoverInfo);
    }

    private static String capsToHash(String str) {
        try {
            return Base64.encodeBytes(MessageDigest.getInstance(HASH_METHOD_CAPS).digest(str.getBytes()));
        } catch (NoSuchAlgorithmException unused) {
            return null;
        }
    }

    private static void cleanupDicsoverInfo(DiscoverInfo discoverInfo) {
        discoverInfo.setFrom(null);
        discoverInfo.setTo(null);
        discoverInfo.setPacketID(null);
    }

    private static String formFieldValuesToCaps(Iterator<String> it2) {
        TreeSet treeSet = new TreeSet();
        while (it2.hasNext()) {
            treeSet.add(it2.next());
        }
        Iterator it3 = treeSet.iterator();
        String str = "";
        while (it3.hasNext()) {
            str = String.valueOf(str) + ((String) it3.next()) + "<";
        }
        return str;
    }

    public static DiscoverInfo getDiscoverInfoByNode(String str) {
        return caps.get(str);
    }

    private void notifyCapsVerListeners() {
        for (CapsVerListener capsVerListener : this.capsVerListeners) {
            capsVerListener.capsVerUpdated(this.currentCapsVersion);
        }
    }

    public void addCapsVerListener(CapsVerListener capsVerListener) {
        this.capsVerListeners.add(capsVerListener);
        String str = this.currentCapsVersion;
        if (str != null) {
            capsVerListener.capsVerUpdated(str);
        }
    }

    public void addPacketListener(Connection connection) {
        connection.addPacketListener(new CapsPacketListener(), new AndFilter(new PacketTypeFilter(Presence.class), new PacketExtensionFilter("c", CapsExtension.XMLNS)));
    }

    public void addUserCapsNode(String str, String str2) {
        if (str != null && str2 != null) {
            this.userCaps.put(str, str2);
        }
    }

    /* access modifiers changed from: package-private */
    public void calculateEntityCapsVersion(DiscoverInfo discoverInfo, String str, String str2, List<String> list, DataForm dataForm) {
        String str3 = "" + "client/" + str + "//" + str2 + "<";
        synchronized (list) {
            TreeSet treeSet = new TreeSet();
            for (String str4 : list) {
                treeSet.add(str4);
            }
            Iterator it2 = treeSet.iterator();
            while (it2.hasNext()) {
                str3 = String.valueOf(str3) + ((String) it2.next()) + "<";
            }
        }
        if (dataForm != null) {
            synchronized (dataForm) {
                TreeSet<FormField> treeSet2 = new TreeSet(new Comparator<FormField>() {
                    /* class asmack.org.jivesoftware.smackx.EntityCapsManager.AnonymousClass1 */

                    public int compare(FormField formField, FormField formField2) {
                        return formField.getVariable().compareTo(formField2.getVariable());
                    }
                });
                FormField formField = null;
                Iterator<FormField> fields = dataForm.getFields();
                while (fields.hasNext()) {
                    FormField next = fields.next();
                    if (!next.getVariable().equals("FORM_TYPE")) {
                        treeSet2.add(next);
                    } else {
                        formField = next;
                    }
                }
                if (formField != null) {
                    str3 = String.valueOf(str3) + formFieldValuesToCaps(formField.getValues());
                }
                for (FormField formField2 : treeSet2) {
                    StringBuilder sb = new StringBuilder(String.valueOf(String.valueOf(str3) + formField2.getVariable() + "<"));
                    sb.append(formFieldValuesToCaps(formField2.getValues()));
                    str3 = sb.toString();
                }
            }
        }
        setCurrentCapsVersion(discoverInfo, capsToHash(str3));
    }

    public String getCapsVersion() {
        return this.currentCapsVersion;
    }

    public DiscoverInfo getDiscoverInfoByUser(String str) {
        String str2 = this.userCaps.get(str);
        if (str2 == null) {
            return null;
        }
        return getDiscoverInfoByNode(str2);
    }

    public String getNode() {
        return entityNode;
    }

    public String getNodeVersionByUser(String str) {
        return this.userCaps.get(str);
    }

    public void removeCapsVerListener(CapsVerListener capsVerListener) {
        this.capsVerListeners.remove(capsVerListener);
    }

    public void removeUserCapsNode(String str) {
        this.userCaps.remove(str);
    }

    public void setCurrentCapsVersion(DiscoverInfo discoverInfo, String str) {
        this.currentCapsVersion = str;
        addDiscoverInfoByNode(String.valueOf(getNode()) + "#" + str, discoverInfo);
        notifyCapsVerListeners();
    }

    public void setNode(String str) {
        entityNode = str;
    }
}