/** Entity Capabilities */ public void setEntityCapsManager(EntityCapsManager manager) { capsManager = manager; if (connection.getCapsNode() != null && connection.getHost() != null) { capsManager.addUserCapsNode(connection.getHost(), connection.getCapsNode()); } capsManager.addPacketListener(connection); }
public void testLocalEntityCaps() throws InterruptedException { DiscoverInfo info = EntityCapsManager.getDiscoveryInfoByNodeVer(ecm1.getLocalNodeVer()); assertFalse(info.containsFeature(DISCOVER_TEST_FEATURE)); dropWholeEntityCapsCache(); // This should cause a new presence stanza from con1 with and updated // 'ver' String sdm1.addFeature(DISCOVER_TEST_FEATURE); // Give the server some time to handle the stanza and send it to con0 Thread.sleep(2000); // The presence stanza should get received by con0 and the data should // be recorded in the map // Note that while both connections use the same static Entity Caps // cache, // it's assured that *not* con1 added the data to the Entity Caps cache. // Every time the entities features // and identities change only a new caps 'ver' is calculated and send // with the presence stanza // The other connection has to receive this stanza and record the // information in order for this test to succeed. info = EntityCapsManager.getDiscoveryInfoByNodeVer(ecm1.getLocalNodeVer()); assertNotNull(info); assertTrue(info.containsFeature(DISCOVER_TEST_FEATURE)); }
/** * Returns the discovered information of a given XMPP entity addressed by its JID. * * @param entityID the address of the XMPP entity. * @return the discovered information. * @throws XMPPException if the operation failed for some reason. */ public DiscoverInfo discoverInfo(String entityID) throws XMPPException { // Check if the have it cached in the Entity Capabilities Manager DiscoverInfo info = discoverInfoByCaps(entityID); if (info != null) { return info; } else { // If the caps node is known, use it in the request. String node = null; if (capsManager != null) { // Get the newest node#version node = capsManager.getNodeVersionByUser(entityID); } // Check if we cached DiscoverInfo for nonCaps entity if (cacheNonCaps && node == null && nonCapsCache.containsKey(entityID)) { return nonCapsCache.get(entityID); } // Discover by requesting from the remote client info = discoverInfo(entityID, node); // If the node version is known, store the new entry. if (node != null && capsManager != null) { EntityCapsManager.addDiscoverInfoByNode(node, info); } // If this is a non caps entity store the discover in nonCapsCache map else if (cacheNonCaps && node == null) { nonCapsCache.put(entityID, info); } return info; } }
public void testCapsChanged() { String nodeVerBefore = EntityCapsManager.getNodeVersionByJid(con1.getUser()); sdm1.addFeature(DISCOVER_TEST_FEATURE); String nodeVerAfter = EntityCapsManager.getNodeVersionByJid(con1.getUser()); assertFalse(nodeVerBefore.equals(nodeVerAfter)); }
@Override protected void setUp() throws Exception { super.setUp(); SmackConfiguration.setAutoEnableEntityCaps(true); con0 = getConnection(0); con1 = getConnection(1); ecm0 = EntityCapsManager.getInstanceFor(getConnection(0)); ecm1 = EntityCapsManager.getInstanceFor(getConnection(1)); sdm0 = ServiceDiscoveryManager.getInstanceFor(con0); sdm1 = ServiceDiscoveryManager.getInstanceFor(con1); letsAllBeFriends(); }
private String getEntityCapsVersion() { if (capsManager != null) { return capsManager.getCapsVersion(); } else { return null; } }
/** * Get a DiscoverInfo for the current entity caps node. * * @return a DiscoverInfo for the current entity caps node */ public DiscoverInfo getOwnDiscoverInfo() { DiscoverInfo di = new DiscoverInfo(); di.setType(IQ.Type.RESULT); di.setNode(capsManager.getNode() + "#" + getEntityCapsVersion()); // Add discover info addDiscoverInfoTo(di); return di; }
private void renewEntityCapsVersion() { // If a XMPPConnection is the managed one, see that the new // version is updated if (connection instanceof XMPPConnection) { if (capsManager != null) { capsManager.calculateEntityCapsVersion( getOwnDiscoverInfo(), identityType, identityName, features, extendedInfo); // capsManager.notifyCapsVerListeners(); } } }
/** * Returns the discovered information of a given XMPP entity addressed by its JID if it's known by * the entity caps manager. * * @param entityID the address of the XMPP entity * @return the disovered info or null if no such info is available from the entity caps manager. * @throws XMPPException if the operation failed for some reason. */ public DiscoverInfo discoverInfoByCaps(String entityID) throws XMPPException { DiscoverInfo info = capsManager.getDiscoverInfoByUser(entityID); if (info != null) { DiscoverInfo newInfo = cloneDiscoverInfo(info); newInfo.setFrom(entityID); return newInfo; } else { return null; } }
/** * Creates a new ServiceDiscoveryManager for a given connection. This means that the service * manager will respond to any service discovery request that the connection may receive. * * @param connection the connection to which a ServiceDiscoveryManager is going to be created. */ public ServiceDiscoveryManager(Connection connection) { this.connection = connection; // For every XMPPConnection, add one EntityCapsManager. if (connection instanceof XMPPConnection) { setEntityCapsManager(new EntityCapsManager()); capsManager.addCapsVerListener(new CapsPresenceRenewer()); } renewEntityCapsVersion(); init(); }
public void testEntityCaps() throws XMPPException, InterruptedException { dropWholeEntityCapsCache(); sdm1.addFeature(DISCOVER_TEST_FEATURE); Thread.sleep(3000); DiscoverInfo info = sdm0.discoverInfo(con1.getUser()); assertTrue(info.containsFeature(DISCOVER_TEST_FEATURE)); String u1ver = EntityCapsManager.getNodeVersionByJid(con1.getUser()); assertNotNull(u1ver); DiscoverInfo entityInfo = EntityCapsManager.caps.get(u1ver); assertNotNull(entityInfo); assertEquals(info.toXML(), entityInfo.toXML()); }