/** * Same as {@link #login(CharSequence, String, Resourcepart)}, but takes the resource from the connection * configuration. * * @param username * @param password * @throws XMPPException * @throws SmackException * @throws IOException * @throws InterruptedException * @see #login */ public synchronized void login(CharSequence username, String password) throws XMPPException, SmackException, IOException, InterruptedException { login(username, password, config.getResource()); }
@Override public SampleResult perform(JMeterXMPPSampler sampler, SampleResult res) throws Exception { XMPPConnection conn = sampler.getXMPPConnection(); String loginStr = sampler.getPropertyAsString(LOGIN); String pwdStr = sampler.getPropertyAsString(PASSWORD); String resStr = sampler.getPropertyAsString(RESOURCE); res.setSamplerData("Username: " + loginStr + "\nPassword: " + pwdStr + "\nResource: " + resStr); AbstractXMPPConnection absConn = (AbstractXMPPConnection) conn; if (loginStr.isEmpty()) { absConn.loginAnonymously(); } else { absConn.login(loginStr, pwdStr, resStr); } return res; }
LOGGER.log(Level.FINER, "Connection was already connected on reconnection attempt", e); connection.login();
public static void deleteViaServiceAdministration(XMPPTCPConnection connection, Configuration config) { EntityBareJid accountToDelete = connection.getUser().asEntityBareJid(); final int maxAttempts = 3; int attempts; for (attempts = 0; attempts < maxAttempts; attempts++) { connection.disconnect(); try { connection.connect().login(config.adminAccountUsername, config.adminAccountPassword); } catch (XMPPException | SmackException | IOException | InterruptedException e) { LOGGER.log(Level.WARNING, "Exception deleting account for " + connection, e); continue; } ServiceAdministrationManager adminManager = ServiceAdministrationManager.getInstanceFor(connection); try { adminManager.deleteUser(accountToDelete); break; } catch (NoResponseException | XMPPErrorException | NotConnectedException | InterruptedException e) { LOGGER.log(Level.WARNING, "Exception deleting account for " + connection, e); continue; } } if (attempts > maxAttempts) { LOGGER.log(Level.SEVERE, "Could not delete account for connection: " + connection); } }
String password = usedPassword != null ? usedPassword : config.getPassword(); Resourcepart resource = usedResource != null ? usedResource : config.getResource(); login(username, password, resource);
@SmackIntegrationTest public void testStreamManagement(XMPPTCPConnection conOne, XMPPTCPConnection conTwo) throws InterruptedException, SmackException, IOException, XMPPException { final String body1 = "Hi, what's up? " + testRunId; final String body2 = "Hi, what's up? I've been just instantly shutdown" + testRunId; final String body3 = "Hi, what's up? I've been just resumed" + testRunId; final StanzaCollector collector = conTwo.createStanzaCollector(new AndFilter( MessageWithBodiesFilter.INSTANCE, FromMatchesFilter.createFull(conOne.getUser()))); try { send(body1, conOne, conTwo); assertMessageWithBodyReceived(body1, collector); conOne.instantShutdown(); send(body2, conOne, conTwo); // Reconnect with xep198 conOne.connect().login(); assertMessageWithBodyReceived(body2, collector); send(body3, conOne, conTwo); assertMessageWithBodyReceived(body3, collector); } finally { collector.cancel(); } }
connection.connect().login(); if (shouldThrow) {
public static void iotScenario(String dataThingJidString, String dataThingPassword, String readingThingJidString, String readingThingPassword, IotScenario scenario) throws Exception { final EntityBareJid dataThingJid = JidCreate.entityBareFrom(dataThingJidString); final EntityBareJid readingThingJid = JidCreate.entityBareFrom(readingThingJidString); final XMPPTCPConnectionConfiguration dataThingConnectionConfiguration = XMPPTCPConnectionConfiguration.builder() .setUsernameAndPassword(dataThingJid.getLocalpart(), dataThingPassword) .setXmppDomain(dataThingJid.asDomainBareJid()).setSecurityMode(SecurityMode.disabled) .enableDefaultDebugger().build(); final XMPPTCPConnectionConfiguration readingThingConnectionConfiguration = XMPPTCPConnectionConfiguration .builder().setUsernameAndPassword(readingThingJid.getLocalpart(), readingThingPassword) .setXmppDomain(readingThingJid.asDomainBareJid()).setSecurityMode(SecurityMode.disabled) .enableDefaultDebugger().build(); final XMPPTCPConnection dataThingConnection = new XMPPTCPConnection(dataThingConnectionConfiguration); final XMPPTCPConnection readingThingConnection = new XMPPTCPConnection(readingThingConnectionConfiguration); dataThingConnection.setReplyTimeout(TIMEOUT); readingThingConnection.setReplyTimeout(TIMEOUT); dataThingConnection.setUseStreamManagement(false); readingThingConnection.setUseStreamManagement(false); try { dataThingConnection.connect().login(); readingThingConnection.connect().login(); scenario.iotScenario(dataThingConnection, readingThingConnection); } finally { dataThingConnection.disconnect(); readingThingConnection.disconnect(); } }
@SmackIntegrationTest public void testMucBookmarksAutojoin(XMPPTCPConnection connection) throws InterruptedException, TestNotPossibleException, XMPPException, SmackException, IOException { final BookmarkManager bookmarkManager = BookmarkManager.getBookmarkManager(connection); if (!bookmarkManager.isSupported()) { throw new TestNotPossibleException("Private data storage not supported"); } final MultiUserChatManager multiUserChatManager = MultiUserChatManager.getInstanceFor(connection); final Resourcepart mucNickname = Resourcepart.from("Nick-" + StringUtils.randomString(6)); final String randomMucName = StringUtils.randomString(6); final DomainBareJid mucComponent = multiUserChatManager.getMucServiceDomains().get(0); final MultiUserChat muc = multiUserChatManager.getMultiUserChat(JidCreate.entityBareFrom( Localpart.from(randomMucName), mucComponent)); MucCreateConfigFormHandle handle = muc.createOrJoin(mucNickname); if (handle != null) { handle.makeInstant(); } muc.leave(); bookmarkManager.addBookmarkedConference("Smack Inttest: " + testRunId, muc.getRoom(), true, mucNickname, null); connection.disconnect(); connection.connect().login(); // MucBookmarkAutojoinManager is also able to do its task automatically // after every login, it's not deterministic when this will be finished. // So we trigger it manually here. MucBookmarkAutojoinManager.getInstanceFor(connection).autojoinBookmarkedConferences(); assertTrue(muc.isJoined()); // If the test went well, leave the MUC muc.leave(); }
public void login() { try { connection.login(userName, passWord); //Log.i("LOGIN", "Yey! We're connected to the Xmpp server!"); } catch (XMPPException | SmackException | IOException e) { e.printStackTrace(); } catch (Exception e) { } }
/** * Same as {@link #login(CharSequence, String, Resourcepart)}, but takes the resource from the connection * configuration. * * @param username * @param password * @throws XMPPException * @throws SmackException * @throws IOException * @throws InterruptedException * @see #login */ public synchronized void login(CharSequence username, String password) throws XMPPException, SmackException, IOException, InterruptedException { login(username, password, config.getResource()); }
config = XMPPTCPConnectionConfiguration.builder() .setUsernameAndPassword("1", "1") .setHost("192.168.1.2") .setSecurityMode(ConnectionConfiguration.SecurityMode.disabled) .setServiceName("davids-macbook-pro.local") .setPort(Integer.parseInt("5222")) .build(); AbstractXMPPConnection conn2 = new XMPPTCPConnection(config); try { conn2.connect(); conn2.login(); } catch (SmackException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } catch (XMPPException e) { e.printStackTrace(); }
XMPPTCPConnectionConfiguration conf = XMPPTCPConnectionConfiguration.builder() .setServiceName(SERVICE_NAME) .setHost(HOST_NAME) .setPort(5222) .setSecurityMode(ConnectionConfiguration.SecurityMode.disabled) .build(); AbstractXMPPConnection connection = new XMPPTCPConnection(conf); connection.connect(); // Here we create the connection // Now we create the account: AccountManager accountManager = AccountManager.getInstance(connection); accountManager.createAccount(username, password); // The account has been created, so we can now login connection.login(username, password);
AbstractXMPPConnection conn = new XMPPTCPConnection("xxx", "yyy", "zzz"); conn.connect(); conn.login();
public class MyConnection implements ConnectionListener { ... XMPPTCPConnectionConfiguration.Builder config = XMPPTCPConnectionConfiguration.builder(); config.setSecurityMode(ConnectionConfiguration.SecurityMode.disabled); config.setUsernameAndPassword(userName + "@" + DOMAIN, password); config.setServiceName(DOMAIN); config.setHost(DOMAIN); config.setPort(PORT); config.setDebuggerEnabled(true); AbstractXMPPConnection mConnection = new XMPPTCPConnection(config.build()); mConnection.setPacketReplyTimeout(10000); mConnection.addConnectionListener(this); try { mConnection.connect(); } catch (SmackException | IOException | XMPPException e) { e.printStackTrace(); } @Override public void connected(XMPPConnection xmppConnection) { Log.d(TAG, "connected"); try { mConnection.login(); } catch (XMPPException | SmackException | IOException e) { e.printStackTrace(); } }
/** * Connect to the XMPP server, login anonymously then join the MUC chatroom. * @throws XMPPException on XMPP protocol errors * @throws SmackException on connection-level errors (i.e. BOSH problems) * @throws IOError on I/O error */ public void start() throws SmackException, IOException, XMPPException { logger.info(this.nickname + " : Login anonymously to the XMPP server."); try { connection.connect(); connection.login(); } catch (InterruptedException e) { logger.fatal("Interrupted while making xmpp connection: " + e.toString()); System.exit(1); } connectMUC(); }
// Create the configuration for this new connection XMPPTCPConnectionConfiguration.Builder configBuilder = XMPPTCPConnectionConfiguration.builder(); configBuilder.setUsernameAndPassword("username", "password"); configBuilder.setResource("SomeResource"); configBuilder.setXmppDomain("jabber.org"); AbstractXMPPConnection connection = new XMPPTCPConnection(configBuilder.build()); // Connect to the server connection.connect(); // Log into the server connection.login(); ... // Disconnect from the server connection.disconnect();
String password = usedPassword != null ? usedPassword : config.getPassword(); Resourcepart resource = usedResource != null ? usedResource : config.getResource(); login(username, password, resource);