private boolean hasSameBareAddress(String account) {
String bareAddress = Jid.getBareAddress(account);
for (AccountItem check : accountItems.values())
if (!check.getAccount().equals(account)
&& Jid.getBareAddress(check.getAccount()).equals(bareAddress)) return true;
return false;
}
private void addAccount(AccountItem accountItem) {
accountItems.put(accountItem.getAccount(), accountItem);
if (accountItem.isEnabled()) enabledAccounts.add(accountItem.getAccount());
for (OnAccountAddedListener listener : application.getManagers(OnAccountAddedListener.class))
listener.onAccountAdded(accountItem);
if (accountItem.isEnabled()) {
onAccountEnabled(accountItem);
if (accountItem.getRawStatusMode().isOnline()) onAccountOnline(accountItem);
}
onAccountChanged(accountItem.getAccount());
}
/** Sends new presence information for all accounts. */
public void resendPresence() {
for (AccountItem accountItem : accountItems.values())
try {
PresenceManager.getInstance().resendPresence(accountItem.getAccount());
} catch (NetworkException e) {
}
}
private boolean hasSameProtocol(String account) {
AccountProtocol protocol = getAccount(account).getConnectionSettings().getProtocol();
for (AccountItem check : accountItems.values())
if (!check.getAccount().equals(account)
&& check.getConnectionSettings().getProtocol() == protocol) return true;
return false;
}
public CommonState getCommonState() {
boolean disabled = false;
boolean offline = false;
boolean waiting = false;
boolean connecting = false;
boolean roster = false;
boolean online = false;
for (AccountItem accountItem : accountItems.values()) {
ConnectionState state = accountItem.getState();
if (state == ConnectionState.connected) online = true;
if (RosterManager.getInstance().isRosterReceived(accountItem.getAccount())) roster = true;
if (state == ConnectionState.connecting || state == ConnectionState.authentication)
connecting = true;
if (state == ConnectionState.waiting) waiting = true;
if (accountItem.isEnabled()) offline = true;
disabled = true;
}
if (online) return CommonState.online;
else if (roster) return CommonState.roster;
else if (connecting) return CommonState.connecting;
if (waiting) return CommonState.waiting;
else if (offline) return CommonState.offline;
else if (disabled) return CommonState.disabled;
else return CommonState.empty;
}
/**
* Update user`s account.
*
* <p>It will reconnect to the server if changes was made.
*
* <p>It will remove old account and create new one if full jid was changed.
*
* @param account full source jid
* @param host
* @param port
* @param serverName
* @param userName
* @param storePassword
* @param password
* @param resource
* @param priority
* @param enabled
* @param saslEnabled
* @param tlsMode
* @param compression
* @param syncable
* @param archiveMode
*/
public void updateAccount(
String account,
boolean custom,
String host,
int port,
String serverName,
String userName,
boolean storePassword,
String password,
String resource,
int priority,
boolean enabled,
boolean saslEnabled,
TLSMode tlsMode,
boolean compression,
ProxyType proxyType,
String proxyHost,
int proxyPort,
String proxyUser,
String proxyPassword,
boolean syncable,
ArchiveMode archiveMode) {
AccountItem result;
AccountItem accountItem = getAccount(account);
if (accountItem.getConnectionSettings().getServerName().equals(serverName)
&& accountItem.getConnectionSettings().getUserName().equals(userName)
&& accountItem.getConnectionSettings().getResource().equals(resource)) {
result = accountItem;
boolean reconnect = false;
if (accountItem.getConnectionSettings().isCustom() != custom
|| !accountItem.getConnectionSettings().getHost().equals(host)
|| accountItem.getConnectionSettings().getPort() != port
|| !accountItem.getConnectionSettings().getPassword().equals(password)
|| accountItem.getConnectionSettings().getTlsMode() != tlsMode
|| accountItem.getConnectionSettings().isSaslEnabled() != saslEnabled
|| accountItem.getConnectionSettings().useCompression() != compression
|| accountItem.getConnectionSettings().getProxyType() != proxyType
|| !accountItem.getConnectionSettings().getProxyHost().equals(proxyHost)
|| accountItem.getConnectionSettings().getProxyPort() != proxyPort
|| !accountItem.getConnectionSettings().getProxyUser().equals(proxyUser)
|| !accountItem.getConnectionSettings().getProxyPassword().equals(proxyPassword)) {
result.updateConnectionSettings(
custom,
host,
port,
password,
saslEnabled,
tlsMode,
compression,
proxyType,
proxyHost,
proxyPort,
proxyUser,
proxyPassword);
reconnect = true;
}
if (result.isSyncable() != syncable) {
result.setSyncable(syncable);
for (OnAccountSyncableChangedListener listener :
application.getManagers(OnAccountSyncableChangedListener.class))
listener.onAccountSyncableChanged(result);
}
result.setStorePassword(storePassword);
boolean changed = result.isEnabled() != enabled;
result.setEnabled(enabled);
if (result.getPriority() != priority) {
result.setPriority(priority);
try {
PresenceManager.getInstance().resendPresence(account);
} catch (NetworkException e) {
}
}
if (result.getArchiveMode() != archiveMode) {
reconnect =
(result.getArchiveMode() == ArchiveMode.server) != (archiveMode == ArchiveMode.server);
result.setArchiveMode(archiveMode);
for (OnAccountArchiveModeChangedListener listener :
application.getManagers(OnAccountArchiveModeChangedListener.class))
listener.onAccountArchiveModeChanged(result);
}
if (changed && enabled) {
enabledAccounts.add(account);
onAccountEnabled(result);
if (result.getRawStatusMode().isOnline()) onAccountOnline(result);
}
if (changed || reconnect) {
result.updateConnection(true);
result.forceReconnect();
}
if (changed && !enabled) {
enabledAccounts.remove(account);
if (result.getRawStatusMode().isOnline()) onAccountOffline(result);
onAccountDisabled(result);
}
requestToWriteAccount(result);
} else {
int colorIndex = accountItem.getColorIndex();
StatusMode statusMode = accountItem.getRawStatusMode();
String statusText = accountItem.getStatusText();
AccountProtocol protocol = accountItem.getConnectionSettings().getProtocol();
KeyPair keyPair = accountItem.getKeyPair();
Date lastSync = accountItem.getLastSync();
removeAccountWithoutCallback(account);
result =
addAccount(
protocol,
custom,
host,
port,
serverName,
userName,
storePassword,
password,
resource,
colorIndex,
priority,
statusMode,
statusText,
enabled,
saslEnabled,
tlsMode,
compression,
proxyType,
proxyHost,
proxyPort,
proxyUser,
proxyPassword,
syncable,
keyPair,
lastSync,
archiveMode);
}
onAccountChanged(result.getAccount());
}
/**
* Creates new account.
*
* @param user full or bare jid.
* @param password
* @param accountType xmpp account type can be replaced depend on server part.
* @param syncable
* @param storePassword
* @param useOrbot
* @return assigned account name.
* @throws NetworkException if user or server part are invalid.
*/
public String addAccount(
String user,
String password,
AccountType accountType,
boolean syncable,
boolean storePassword,
boolean useOrbot)
throws NetworkException {
if (accountType.getProtocol().isOAuth()) {
int index = 1;
while (true) {
user = String.valueOf(index);
boolean found = false;
for (AccountItem accountItem : accountItems.values())
if (accountItem
.getConnectionSettings()
.getServerName()
.equals(accountType.getFirstServer())
&& accountItem.getConnectionSettings().getUserName().equals(user)) {
found = true;
break;
}
if (!found) break;
index++;
}
}
if (user == null) throw new NetworkException(R.string.EMPTY_USER_NAME);
if (user.indexOf("@") == -1) {
if ("".equals(accountType.getFirstServer()))
throw new NetworkException(R.string.EMPTY_SERVER_NAME);
else user += "@" + accountType.getFirstServer();
}
String serverName = StringUtils.parseServer(user);
String userName = StringUtils.parseName(user);
String resource = StringUtils.parseResource(user);
String host = accountType.getHost();
int port = accountType.getPort();
boolean tlsRequired = accountType.isTLSRequired();
if (useOrbot) tlsRequired = true;
if ("".equals(serverName)) {
throw new NetworkException(R.string.EMPTY_SERVER_NAME);
} else if (!accountType.isAllowServer() && !serverName.equals(accountType.getFirstServer()))
throw new NetworkException(R.string.INCORRECT_USER_NAME);
if ("".equals(userName)) throw new NetworkException(R.string.EMPTY_USER_NAME);
if ("".equals(resource)) resource = "android" + StringUtils.randomString(8);
if (accountType.getId() == R.array.account_type_xmpp) {
host = serverName;
for (AccountType check : accountTypes)
if (check.getServers().contains(serverName)) {
accountType = check;
host = check.getHost();
port = check.getPort();
tlsRequired = check.isTLSRequired();
break;
}
}
AccountItem accountItem;
for (; ; ) {
if (getAccount(userName + '@' + serverName + '/' + resource) == null) break;
resource = "android" + StringUtils.randomString(8);
}
accountItem =
addAccount(
accountType.getProtocol(),
true,
host,
port,
serverName,
userName,
storePassword,
password,
resource,
getNextColorIndex(),
0,
StatusMode.available,
SettingsManager.statusText(),
true,
true,
tlsRequired ? TLSMode.required : TLSMode.enabled,
false,
useOrbot ? ProxyType.orbot : ProxyType.none,
"localhost",
8080,
"",
"",
syncable,
null,
null,
ArchiveMode.available);
onAccountChanged(accountItem.getAccount());
if (accountItems.size() > 1 && SettingsManager.contactsEnableShowAccounts())
SettingsManager.enableContactsShowAccount();
return accountItem.getAccount();
}
