package asmack.org.jivesoftware.smackx;
import asmack.org.jivesoftware.smack.Connection;
import asmack.org.jivesoftware.smack.ConnectionCreationListener;
import asmack.org.jivesoftware.smack.ConnectionListener;
import asmack.org.jivesoftware.smack.PacketCollector;
import asmack.org.jivesoftware.smack.PacketInterceptor;
import asmack.org.jivesoftware.smack.PacketListener;
import asmack.org.jivesoftware.smack.SmackConfiguration;
import asmack.org.jivesoftware.smack.XMPPConnection;
import asmack.org.jivesoftware.smack.XMPPException;
import asmack.org.jivesoftware.smack.filter.PacketIDFilter;
import asmack.org.jivesoftware.smack.filter.PacketTypeFilter;
import asmack.org.jivesoftware.smack.packet.IQ;
import asmack.org.jivesoftware.smack.packet.Packet;
import asmack.org.jivesoftware.smack.packet.Presence;
import asmack.org.jivesoftware.smack.packet.XMPPError;
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.packet.DiscoverItems;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
public class ServiceDiscoveryManager {
private static boolean cacheNonCaps = true;
private static String entityNode = "http://www.igniterealtime.org/projects/smack/";
private static String identityName = "Smack";
private static String identityType = "pc";
private static Map<Connection, ServiceDiscoveryManager> instances = new ConcurrentHashMap();
private EntityCapsManager capsManager;
private Connection connection;
private String currentCapsVersion = null;
private DataForm extendedInfo = null;
private final List<String> features = new ArrayList();
private Map<String, NodeInformationProvider> nodeInformationProviders = new ConcurrentHashMap();
private Map<String, DiscoverInfo> nonCapsCache = new ConcurrentHashMap();
private boolean sendPresence = false;
private class CapsPresenceRenewer implements CapsVerListener {
private CapsPresenceRenewer() {
}
/* synthetic */ CapsPresenceRenewer(ServiceDiscoveryManager serviceDiscoveryManager, CapsPresenceRenewer capsPresenceRenewer) {
this();
}
@Override // asmack.org.jivesoftware.smackx.CapsVerListener
public void capsVerUpdated(String str) {
if (!((XMPPConnection) ServiceDiscoveryManager.this.connection).isAuthenticated()) {
return;
}
if (((XMPPConnection) ServiceDiscoveryManager.this.connection).isSendPresence() || ServiceDiscoveryManager.this.isSendPresence()) {
ServiceDiscoveryManager.this.connection.sendPacket(new Presence(Presence.Type.available));
}
}
}
static {
Connection.addConnectionCreationListener(new ConnectionCreationListener() {
/* class asmack.org.jivesoftware.smackx.ServiceDiscoveryManager.AnonymousClass1 */
@Override // asmack.org.jivesoftware.smack.ConnectionCreationListener
public void connectionCreated(Connection connection) {
new ServiceDiscoveryManager(connection);
}
});
}
public ServiceDiscoveryManager(Connection connection2) {
this.connection = connection2;
if (connection2 instanceof XMPPConnection) {
setEntityCapsManager(new EntityCapsManager());
this.capsManager.addCapsVerListener(new CapsPresenceRenewer(this, null));
}
renewEntityCapsVersion();
init();
}
public static boolean canPublishItems(DiscoverInfo discoverInfo) {
return discoverInfo.containsFeature("http://jabber.org/protocol/disco#publish");
}
private DiscoverInfo cloneDiscoverInfo(DiscoverInfo discoverInfo) {
return discoverInfo.clone();
}
/* access modifiers changed from: private */
/* access modifiers changed from: public */
private String getEntityCapsVersion() {
EntityCapsManager entityCapsManager = this.capsManager;
if (entityCapsManager != null) {
return entityCapsManager.getCapsVersion();
}
return null;
}
public static String getIdentityName() {
return identityName;
}
public static String getIdentityType() {
return identityType;
}
public static ServiceDiscoveryManager getInstanceFor(Connection connection2) {
return instances.get(connection2);
}
/* access modifiers changed from: private */
/* access modifiers changed from: public */
private NodeInformationProvider getNodeInformationProvider(String str) {
if (str == null) {
return null;
}
return this.nodeInformationProviders.get(str);
}
private void init() {
instances.put(this.connection, this);
this.connection.addConnectionListener(new ConnectionListener() {
/* class asmack.org.jivesoftware.smackx.ServiceDiscoveryManager.AnonymousClass2 */
@Override // asmack.org.jivesoftware.smack.ConnectionListener
public void connectionClosed() {
ServiceDiscoveryManager.instances.remove(ServiceDiscoveryManager.this.connection);
}
@Override // asmack.org.jivesoftware.smack.ConnectionListener
public void connectionClosedOnError(Exception exc) {
}
@Override // asmack.org.jivesoftware.smack.ConnectionListener
public void reconnectingIn(int i) {
}
@Override // asmack.org.jivesoftware.smack.ConnectionListener
public void reconnectionFailed(Exception exc) {
}
@Override // asmack.org.jivesoftware.smack.ConnectionListener
public void reconnectionSuccessful() {
}
});
PacketTypeFilter packetTypeFilter = new PacketTypeFilter(Presence.class);
this.connection.addPacketInterceptor(new PacketInterceptor() {
/* class asmack.org.jivesoftware.smackx.ServiceDiscoveryManager.AnonymousClass3 */
@Override // asmack.org.jivesoftware.smack.PacketInterceptor
public void interceptPacket(Packet packet) {
if (ServiceDiscoveryManager.this.capsManager != null) {
packet.addExtension(new CapsExtension(ServiceDiscoveryManager.this.capsManager.getNode(), ServiceDiscoveryManager.this.getEntityCapsVersion(), EntityCapsManager.HASH_METHOD));
}
}
}, packetTypeFilter);
PacketTypeFilter packetTypeFilter2 = new PacketTypeFilter(DiscoverItems.class);
this.connection.addPacketListener(new PacketListener() {
/* class asmack.org.jivesoftware.smackx.ServiceDiscoveryManager.AnonymousClass4 */
@Override // asmack.org.jivesoftware.smack.PacketListener
public void processPacket(Packet packet) {
DiscoverItems discoverItems = (DiscoverItems) packet;
if (discoverItems != null && discoverItems.getType() == IQ.Type.GET) {
DiscoverItems discoverItems2 = new DiscoverItems();
discoverItems2.setType(IQ.Type.RESULT);
discoverItems2.setTo(discoverItems.getFrom());
discoverItems2.setPacketID(discoverItems.getPacketID());
discoverItems2.setNode(discoverItems.getNode());
NodeInformationProvider nodeInformationProvider = ServiceDiscoveryManager.this.getNodeInformationProvider(discoverItems.getNode());
if (nodeInformationProvider != null) {
List<DiscoverItems.Item> nodeItems = nodeInformationProvider.getNodeItems();
if (nodeItems != null) {
for (DiscoverItems.Item item : nodeItems) {
discoverItems2.addItem(item);
}
}
} else if (discoverItems.getNode() != null) {
discoverItems2.setType(IQ.Type.ERROR);
discoverItems2.setError(new XMPPError(XMPPError.Condition.item_not_found));
}
ServiceDiscoveryManager.this.connection.sendPacket(discoverItems2);
}
}
}, packetTypeFilter2);
PacketTypeFilter packetTypeFilter3 = new PacketTypeFilter(DiscoverInfo.class);
this.connection.addPacketListener(new PacketListener() {
/* class asmack.org.jivesoftware.smackx.ServiceDiscoveryManager.AnonymousClass5 */
@Override // asmack.org.jivesoftware.smack.PacketListener
public void processPacket(Packet packet) {
DiscoverInfo discoverInfo = (DiscoverInfo) packet;
if (discoverInfo != null && discoverInfo.getType() == IQ.Type.GET) {
DiscoverInfo discoverInfo2 = new DiscoverInfo();
discoverInfo2.setType(IQ.Type.RESULT);
discoverInfo2.setTo(discoverInfo.getFrom());
discoverInfo2.setPacketID(discoverInfo.getPacketID());
discoverInfo2.setNode(discoverInfo.getNode());
if (!(discoverInfo.getNode() == null || ServiceDiscoveryManager.this.capsManager == null)) {
if (!(String.valueOf(ServiceDiscoveryManager.this.capsManager.getNode()) + "#" + ServiceDiscoveryManager.this.getEntityCapsVersion()).equals(discoverInfo.getNode())) {
NodeInformationProvider nodeInformationProvider = ServiceDiscoveryManager.this.getNodeInformationProvider(discoverInfo.getNode());
if (nodeInformationProvider != null) {
List<String> nodeFeatures = nodeInformationProvider.getNodeFeatures();
if (nodeFeatures != null) {
for (String str : nodeFeatures) {
discoverInfo2.addFeature(str);
}
}
List<DiscoverInfo.Identity> nodeIdentities = nodeInformationProvider.getNodeIdentities();
if (nodeIdentities != null) {
for (DiscoverInfo.Identity identity : nodeIdentities) {
discoverInfo2.addIdentity(identity);
}
}
} else {
discoverInfo2.setType(IQ.Type.ERROR);
discoverInfo2.setError(new XMPPError(XMPPError.Condition.item_not_found));
}
ServiceDiscoveryManager.this.connection.sendPacket(discoverInfo2);
}
}
ServiceDiscoveryManager.this.addDiscoverInfoTo(discoverInfo2);
ServiceDiscoveryManager.this.connection.sendPacket(discoverInfo2);
}
}
}, packetTypeFilter3);
}
public static boolean isNonCapsCachingEnabled() {
return cacheNonCaps;
}
/* access modifiers changed from: private */
/* access modifiers changed from: public */
private boolean isSendPresence() {
return this.sendPresence;
}
private void renewEntityCapsVersion() {
EntityCapsManager entityCapsManager;
if ((this.connection instanceof XMPPConnection) && (entityCapsManager = this.capsManager) != null) {
entityCapsManager.calculateEntityCapsVersion(getOwnDiscoverInfo(), identityType, identityName, this.features, this.extendedInfo);
}
}
public static void setIdentityName(String str) {
identityName = str;
}
public static void setIdentityType(String str) {
identityType = str;
}
public static void setNonCapsCaching(boolean z) {
cacheNonCaps = true;
}
private void setSendPresence() {
this.sendPresence = true;
}
public void addDiscoverInfoTo(DiscoverInfo discoverInfo) {
DiscoverInfo.Identity identity = new DiscoverInfo.Identity("client", getIdentityName());
identity.setType(getIdentityType());
discoverInfo.addIdentity(identity);
synchronized (this.features) {
discoverInfo.addFeature(CapsExtension.XMLNS);
Iterator<String> features2 = getFeatures();
while (features2.hasNext()) {
discoverInfo.addFeature(features2.next());
}
if (this.extendedInfo != null) {
discoverInfo.addExtension(this.extendedInfo);
}
}
}
public void addFeature(String str) {
synchronized (this.features) {
this.features.add(str);
renewEntityCapsVersion();
}
}
public boolean canPublishItems(String str) throws XMPPException {
return canPublishItems(discoverInfo(str));
}
public DiscoverInfo discoverInfo(String str) throws XMPPException {
DiscoverInfo discoverInfoByCaps = discoverInfoByCaps(str);
if (discoverInfoByCaps != null) {
return discoverInfoByCaps;
}
String str2 = null;
EntityCapsManager entityCapsManager = this.capsManager;
if (entityCapsManager != null) {
str2 = entityCapsManager.getNodeVersionByUser(str);
}
if (cacheNonCaps && str2 == null && this.nonCapsCache.containsKey(str)) {
return this.nonCapsCache.get(str);
}
DiscoverInfo discoverInfo = discoverInfo(str, str2);
if (str2 != null && this.capsManager != null) {
EntityCapsManager.addDiscoverInfoByNode(str2, discoverInfo);
} else if (cacheNonCaps && str2 == null) {
this.nonCapsCache.put(str, discoverInfo);
}
return discoverInfo;
}
public DiscoverInfo discoverInfo(String str, String str2) throws XMPPException {
DiscoverInfo discoverInfo = new DiscoverInfo();
discoverInfo.setType(IQ.Type.GET);
discoverInfo.setTo(str);
discoverInfo.setNode(str2);
PacketCollector createPacketCollector = this.connection.createPacketCollector(new PacketIDFilter(discoverInfo.getPacketID()));
this.connection.sendPacket(discoverInfo);
IQ iq = (IQ) createPacketCollector.nextResult((long) SmackConfiguration.getPacketReplyTimeout());
createPacketCollector.cancel();
if (iq == null) {
throw new XMPPException("No response from the server.");
} else if (iq.getType() != IQ.Type.ERROR) {
return (DiscoverInfo) iq;
} else {
throw new XMPPException(iq.getError());
}
}
public DiscoverInfo discoverInfoByCaps(String str) throws XMPPException {
DiscoverInfo discoverInfoByUser = this.capsManager.getDiscoverInfoByUser(str);
if (discoverInfoByUser == null) {
return null;
}
DiscoverInfo cloneDiscoverInfo = cloneDiscoverInfo(discoverInfoByUser);
cloneDiscoverInfo.setFrom(str);
return cloneDiscoverInfo;
}
public DiscoverItems discoverItems(String str) throws XMPPException {
return discoverItems(str, null);
}
public DiscoverItems discoverItems(String str, String str2) throws XMPPException {
DiscoverItems discoverItems = new DiscoverItems();
discoverItems.setType(IQ.Type.GET);
discoverItems.setTo(str);
discoverItems.setNode(str2);
PacketCollector createPacketCollector = this.connection.createPacketCollector(new PacketIDFilter(discoverItems.getPacketID()));
this.connection.sendPacket(discoverItems);
IQ iq = (IQ) createPacketCollector.nextResult((long) SmackConfiguration.getPacketReplyTimeout());
createPacketCollector.cancel();
if (iq == null) {
throw new XMPPException("No response from the server.");
} else if (iq.getType() != IQ.Type.ERROR) {
return (DiscoverItems) iq;
} else {
throw new XMPPException(iq.getError());
}
}
public EntityCapsManager getEntityCapsManager() {
return this.capsManager;
}
public Iterator<String> getFeatures() {
Iterator<String> it2;
synchronized (this.features) {
it2 = Collections.unmodifiableList(new ArrayList(this.features)).iterator();
}
return it2;
}
public DiscoverInfo getOwnDiscoverInfo() {
DiscoverInfo discoverInfo = new DiscoverInfo();
discoverInfo.setType(IQ.Type.RESULT);
discoverInfo.setNode(String.valueOf(this.capsManager.getNode()) + "#" + getEntityCapsVersion());
addDiscoverInfoTo(discoverInfo);
return discoverInfo;
}
public boolean includesFeature(String str) {
boolean contains;
synchronized (this.features) {
contains = this.features.contains(str);
}
return contains;
}
public void publishItems(String str, DiscoverItems discoverItems) throws XMPPException {
publishItems(str, null, discoverItems);
}
public void publishItems(String str, String str2, DiscoverItems discoverItems) throws XMPPException {
discoverItems.setType(IQ.Type.SET);
discoverItems.setTo(str);
discoverItems.setNode(str2);
PacketCollector createPacketCollector = this.connection.createPacketCollector(new PacketIDFilter(discoverItems.getPacketID()));
this.connection.sendPacket(discoverItems);
IQ iq = (IQ) createPacketCollector.nextResult((long) SmackConfiguration.getPacketReplyTimeout());
createPacketCollector.cancel();
if (iq == null) {
throw new XMPPException("No response from the server.");
} else if (iq.getType() == IQ.Type.ERROR) {
throw new XMPPException(iq.getError());
}
}
public void removeExtendedInfo() {
this.extendedInfo = null;
renewEntityCapsVersion();
}
public void removeFeature(String str) {
synchronized (this.features) {
this.features.remove(str);
renewEntityCapsVersion();
}
}
public void removeNodeInformationProvider(String str) {
this.nodeInformationProviders.remove(str);
}
public void setEntityCapsManager(EntityCapsManager entityCapsManager) {
this.capsManager = entityCapsManager;
if (!(this.connection.getCapsNode() == null || this.connection.getHost() == null)) {
this.capsManager.addUserCapsNode(this.connection.getHost(), this.connection.getCapsNode());
}
this.capsManager.addPacketListener(this.connection);
}
public void setExtendedInfo(DataForm dataForm) {
this.extendedInfo = dataForm;
renewEntityCapsVersion();
}
public void setNodeInformationProvider(String str, NodeInformationProvider nodeInformationProvider) {
this.nodeInformationProviders.put(str, nodeInformationProvider);
}
}