1package eu.siacs.conversations.services;
   2
   3import android.annotation.SuppressLint;
   4import android.app.AlarmManager;
   5import android.app.PendingIntent;
   6import android.app.Service;
   7import android.content.Context;
   8import android.content.Intent;
   9import android.content.SharedPreferences;
  10import android.database.ContentObserver;
  11import android.graphics.Bitmap;
  12import android.net.ConnectivityManager;
  13import android.net.NetworkInfo;
  14import android.net.Uri;
  15import android.os.Binder;
  16import android.os.Bundle;
  17import android.os.FileObserver;
  18import android.os.IBinder;
  19import android.os.PowerManager;
  20import android.os.PowerManager.WakeLock;
  21import android.os.SystemClock;
  22import android.preference.PreferenceManager;
  23import android.provider.ContactsContract;
  24import android.util.Log;
  25import android.util.LruCache;
  26
  27import net.java.otr4j.OtrException;
  28import net.java.otr4j.session.Session;
  29import net.java.otr4j.session.SessionID;
  30import net.java.otr4j.session.SessionStatus;
  31
  32import org.openintents.openpgp.util.OpenPgpApi;
  33import org.openintents.openpgp.util.OpenPgpServiceConnection;
  34
  35import java.math.BigInteger;
  36import java.security.SecureRandom;
  37import java.util.ArrayList;
  38import java.util.Collection;
  39import java.util.Collections;
  40import java.util.Comparator;
  41import java.util.Hashtable;
  42import java.util.List;
  43import java.util.Locale;
  44import java.util.Map;
  45import java.util.concurrent.CopyOnWriteArrayList;
  46
  47import de.duenndns.ssl.MemorizingTrustManager;
  48import eu.siacs.conversations.Config;
  49import eu.siacs.conversations.R;
  50import eu.siacs.conversations.crypto.PgpEngine;
  51import eu.siacs.conversations.entities.Account;
  52import eu.siacs.conversations.entities.Blockable;
  53import eu.siacs.conversations.entities.Bookmark;
  54import eu.siacs.conversations.entities.Contact;
  55import eu.siacs.conversations.entities.Conversation;
  56import eu.siacs.conversations.entities.Downloadable;
  57import eu.siacs.conversations.entities.DownloadablePlaceholder;
  58import eu.siacs.conversations.entities.Message;
  59import eu.siacs.conversations.entities.MucOptions;
  60import eu.siacs.conversations.entities.MucOptions.OnRenameListener;
  61import eu.siacs.conversations.entities.Presences;
  62import eu.siacs.conversations.generator.IqGenerator;
  63import eu.siacs.conversations.generator.MessageGenerator;
  64import eu.siacs.conversations.generator.PresenceGenerator;
  65import eu.siacs.conversations.http.HttpConnectionManager;
  66import eu.siacs.conversations.parser.IqParser;
  67import eu.siacs.conversations.parser.MessageParser;
  68import eu.siacs.conversations.parser.PresenceParser;
  69import eu.siacs.conversations.persistance.DatabaseBackend;
  70import eu.siacs.conversations.persistance.FileBackend;
  71import eu.siacs.conversations.ui.UiCallback;
  72import eu.siacs.conversations.utils.CryptoHelper;
  73import eu.siacs.conversations.utils.ExceptionHelper;
  74import eu.siacs.conversations.utils.OnPhoneContactsLoadedListener;
  75import eu.siacs.conversations.utils.PRNGFixes;
  76import eu.siacs.conversations.utils.PhoneHelper;
  77import eu.siacs.conversations.utils.Xmlns;
  78import eu.siacs.conversations.xml.Element;
  79import eu.siacs.conversations.xmpp.OnBindListener;
  80import eu.siacs.conversations.xmpp.OnContactStatusChanged;
  81import eu.siacs.conversations.xmpp.OnIqPacketReceived;
  82import eu.siacs.conversations.xmpp.OnMessageAcknowledged;
  83import eu.siacs.conversations.xmpp.OnMessagePacketReceived;
  84import eu.siacs.conversations.xmpp.OnPresencePacketReceived;
  85import eu.siacs.conversations.xmpp.OnStatusChanged;
  86import eu.siacs.conversations.xmpp.OnUpdateBlocklist;
  87import eu.siacs.conversations.xmpp.XmppConnection;
  88import eu.siacs.conversations.xmpp.forms.Data;
  89import eu.siacs.conversations.xmpp.forms.Field;
  90import eu.siacs.conversations.xmpp.jid.InvalidJidException;
  91import eu.siacs.conversations.xmpp.jid.Jid;
  92import eu.siacs.conversations.xmpp.jingle.JingleConnectionManager;
  93import eu.siacs.conversations.xmpp.jingle.OnJinglePacketReceived;
  94import eu.siacs.conversations.xmpp.jingle.stanzas.JinglePacket;
  95import eu.siacs.conversations.xmpp.pep.Avatar;
  96import eu.siacs.conversations.xmpp.stanzas.IqPacket;
  97import eu.siacs.conversations.xmpp.stanzas.MessagePacket;
  98import eu.siacs.conversations.xmpp.stanzas.PresencePacket;
  99
 100public class XmppConnectionService extends Service implements OnPhoneContactsLoadedListener {
 101
 102	public static final String ACTION_CLEAR_NOTIFICATION = "clear_notification";
 103	private static final String ACTION_MERGE_PHONE_CONTACTS = "merge_phone_contacts";
 104	public static final String ACTION_DISABLE_FOREGROUND = "disable_foreground";
 105
 106	private ContentObserver contactObserver = new ContentObserver(null) {
 107		@Override
 108		public void onChange(boolean selfChange) {
 109			super.onChange(selfChange);
 110			Intent intent = new Intent(getApplicationContext(),
 111					XmppConnectionService.class);
 112			intent.setAction(ACTION_MERGE_PHONE_CONTACTS);
 113			startService(intent);
 114		}
 115	};
 116	private final IBinder mBinder = new XmppConnectionBinder();
 117	public DatabaseBackend databaseBackend;
 118	public OnContactStatusChanged onContactStatusChanged = new OnContactStatusChanged() {
 119
 120		@Override
 121		public void onContactStatusChanged(Contact contact, boolean online) {
 122			Conversation conversation = find(getConversations(), contact);
 123			if (conversation != null) {
 124				if (online && contact.getPresences().size() > 1) {
 125					conversation.endOtrIfNeeded();
 126				} else {
 127					conversation.resetOtrSession();
 128				}
 129				if (online && (contact.getPresences().size() == 1)) {
 130					sendUnsentMessages(conversation);
 131				}
 132			}
 133		}
 134	};
 135	private FileBackend fileBackend = new FileBackend(this);
 136	private MemorizingTrustManager mMemorizingTrustManager;
 137	private NotificationService mNotificationService = new NotificationService(
 138			this);
 139	private OnMessagePacketReceived mMessageParser = new MessageParser(this);
 140	private OnPresencePacketReceived mPresenceParser = new PresenceParser(this);
 141	private IqParser mIqParser = new IqParser(this);
 142	private MessageGenerator mMessageGenerator = new MessageGenerator(this);
 143	private PresenceGenerator mPresenceGenerator = new PresenceGenerator(this);
 144	private List<Account> accounts;
 145	private final List<Conversation> conversations = new CopyOnWriteArrayList<>();
 146	private JingleConnectionManager mJingleConnectionManager = new JingleConnectionManager(
 147			this);
 148	private HttpConnectionManager mHttpConnectionManager = new HttpConnectionManager(
 149			this);
 150	private AvatarService mAvatarService = new AvatarService(this);
 151	private MessageArchiveService mMessageArchiveService = new MessageArchiveService(this);
 152	private OnConversationUpdate mOnConversationUpdate = null;
 153	private Integer convChangedListenerCount = 0;
 154	private OnAccountUpdate mOnAccountUpdate = null;
 155	private OnStatusChanged statusListener = new OnStatusChanged() {
 156
 157		@Override
 158		public void onStatusChanged(Account account) {
 159			XmppConnection connection = account.getXmppConnection();
 160			if (mOnAccountUpdate != null) {
 161				mOnAccountUpdate.onAccountUpdate();
 162			}
 163			if (account.getStatus() == Account.State.ONLINE) {
 164				for (Conversation conversation : account.pendingConferenceLeaves) {
 165					leaveMuc(conversation);
 166				}
 167				for (Conversation conversation : account.pendingConferenceJoins) {
 168					joinMuc(conversation);
 169				}
 170				mMessageArchiveService.executePendingQueries(account);
 171				mJingleConnectionManager.cancelInTransmission();
 172				List<Conversation> conversations = getConversations();
 173				for (Conversation conversation : conversations) {
 174					if (conversation.getAccount() == account) {
 175						conversation.startOtrIfNeeded();
 176						sendUnsentMessages(conversation);
 177					}
 178				}
 179				if (connection != null && connection.getFeatures().csi()) {
 180					if (checkListeners()) {
 181						Log.d(Config.LOGTAG, account.getJid().toBareJid()
 182								+ " sending csi//inactive");
 183						connection.sendInactive();
 184					} else {
 185						Log.d(Config.LOGTAG, account.getJid().toBareJid()
 186								+ " sending csi//active");
 187						connection.sendActive();
 188					}
 189				}
 190				syncDirtyContacts(account);
 191				scheduleWakeupCall(Config.PING_MAX_INTERVAL, true);
 192			} else if (account.getStatus() == Account.State.OFFLINE) {
 193				resetSendingToWaiting(account);
 194				if (!account.isOptionSet(Account.OPTION_DISABLED)) {
 195					int timeToReconnect = mRandom.nextInt(50) + 10;
 196					scheduleWakeupCall(timeToReconnect, false);
 197				}
 198			} else if (account.getStatus() == Account.State.REGISTRATION_SUCCESSFUL) {
 199				databaseBackend.updateAccount(account);
 200				reconnectAccount(account, true);
 201			} else if ((account.getStatus() != Account.State.CONNECTING)
 202					&& (account.getStatus() != Account.State.NO_INTERNET)) {
 203				if (connection != null) {
 204					int next = connection.getTimeToNextAttempt();
 205					Log.d(Config.LOGTAG, account.getJid().toBareJid()
 206							+ ": error connecting account. try again in "
 207							+ next + "s for the "
 208							+ (connection.getAttempt() + 1) + " time");
 209					scheduleWakeupCall((int) (next * 1.2), false);
 210				}
 211					}
 212			getNotificationService().updateErrorNotification();
 213		}
 214	};
 215
 216	private int accountChangedListenerCount = 0;
 217	private OnRosterUpdate mOnRosterUpdate = null;
 218	private OnUpdateBlocklist mOnUpdateBlocklist = null;
 219	private int updateBlocklistListenerCount = 0;
 220	private int rosterChangedListenerCount = 0;
 221	private OnMucRosterUpdate mOnMucRosterUpdate = null;
 222	private int mucRosterChangedListenerCount = 0;
 223	private SecureRandom mRandom;
 224	private final FileObserver fileObserver = new FileObserver(
 225			FileBackend.getConversationsImageDirectory()) {
 226
 227		@Override
 228		public void onEvent(int event, String path) {
 229			if (event == FileObserver.DELETE) {
 230				markFileDeleted(path.split("\\.")[0]);
 231			}
 232		}
 233	};
 234	private final OnJinglePacketReceived jingleListener = new OnJinglePacketReceived() {
 235
 236		@Override
 237		public void onJinglePacketReceived(Account account, JinglePacket packet) {
 238			mJingleConnectionManager.deliverPacket(account, packet);
 239		}
 240	};
 241
 242	private OpenPgpServiceConnection pgpServiceConnection;
 243	private PgpEngine mPgpEngine = null;
 244	private Intent pingIntent;
 245	private PendingIntent pendingPingIntent = null;
 246	private WakeLock wakeLock;
 247	private PowerManager pm;
 248	private final OnBindListener mOnBindListener = new OnBindListener() {
 249
 250		@Override
 251		public void onBind(final Account account) {
 252			account.getRoster().clearPresences();
 253			account.pendingConferenceJoins.clear();
 254			account.pendingConferenceLeaves.clear();
 255			fetchRosterFromServer(account);
 256			fetchBookmarks(account);
 257			sendPresencePacket(account,mPresenceGenerator.sendPresence(account));
 258			connectMultiModeConversations(account);
 259			updateConversationUi();
 260		}
 261	};
 262
 263	private final OnMessageAcknowledged mOnMessageAcknowledgedListener = new OnMessageAcknowledged() {
 264
 265		@Override
 266		public void onMessageAcknowledged(Account account, String uuid) {
 267			for (final Conversation conversation : getConversations()) {
 268				if (conversation.getAccount() == account) {
 269					Message message = conversation.findUnsentMessageWithUuid(uuid);
 270					if (message != null) {
 271						markMessage(message, Message.STATUS_SEND);
 272						if (conversation.setLastMessageTransmitted(System.currentTimeMillis())) {
 273							databaseBackend.updateConversation(conversation);
 274						}
 275					}
 276				}
 277			}
 278		}
 279	};
 280	private LruCache<String, Bitmap> mBitmapCache;
 281	private final IqGenerator mIqGenerator = new IqGenerator(this);
 282	private Thread mPhoneContactMergerThread;
 283
 284	public PgpEngine getPgpEngine() {
 285		if (pgpServiceConnection.isBound()) {
 286			if (this.mPgpEngine == null) {
 287				this.mPgpEngine = new PgpEngine(new OpenPgpApi(
 288							getApplicationContext(),
 289							pgpServiceConnection.getService()), this);
 290			}
 291			return mPgpEngine;
 292		} else {
 293			return null;
 294		}
 295
 296	}
 297
 298	public FileBackend getFileBackend() {
 299		return this.fileBackend;
 300	}
 301
 302	public AvatarService getAvatarService() {
 303		return this.mAvatarService;
 304	}
 305
 306	public void attachFileToConversation(final Conversation conversation,
 307			final Uri uri,
 308			final UiCallback<Message> callback) {
 309		final Message message;
 310		if (conversation.getNextEncryption(forceEncryption()) == Message.ENCRYPTION_PGP) {
 311			message = new Message(conversation, "",
 312					Message.ENCRYPTION_DECRYPTED);
 313		} else {
 314			message = new Message(conversation, "",
 315					conversation.getNextEncryption(forceEncryption()));
 316		}
 317		message.setCounterpart(conversation.getNextCounterpart());
 318		message.setType(Message.TYPE_FILE);
 319		message.setStatus(Message.STATUS_OFFERED);
 320		String path = getFileBackend().getOriginalPath(uri);
 321		if (path!=null) {
 322			message.setRelativeFilePath(path);
 323			getFileBackend().updateFileParams(message);
 324			if (message.getEncryption() == Message.ENCRYPTION_DECRYPTED) {
 325				getPgpEngine().encrypt(message, callback);
 326			} else {
 327				callback.success(message);
 328			}
 329		} else {
 330			new Thread(new Runnable() {
 331				@Override
 332				public void run() {
 333					try {
 334						getFileBackend().copyFileToPrivateStorage(message, uri);
 335						getFileBackend().updateFileParams(message);
 336						if (message.getEncryption() == Message.ENCRYPTION_DECRYPTED) {
 337							getPgpEngine().encrypt(message, callback);
 338						} else {
 339							callback.success(message);
 340						}
 341					} catch (FileBackend.FileCopyException e) {
 342						callback.error(e.getResId(),message);
 343					}
 344				}
 345			}).start();
 346
 347		}
 348	}
 349
 350	public void attachImageToConversation(final Conversation conversation,
 351			final Uri uri, final UiCallback<Message> callback) {
 352		final Message message;
 353		if (conversation.getNextEncryption(forceEncryption()) == Message.ENCRYPTION_PGP) {
 354			message = new Message(conversation, "",
 355					Message.ENCRYPTION_DECRYPTED);
 356		} else {
 357			message = new Message(conversation, "",
 358					conversation.getNextEncryption(forceEncryption()));
 359		}
 360		message.setCounterpart(conversation.getNextCounterpart());
 361		message.setType(Message.TYPE_IMAGE);
 362		message.setStatus(Message.STATUS_OFFERED);
 363		new Thread(new Runnable() {
 364
 365			@Override
 366			public void run() {
 367				try {
 368					getFileBackend().copyImageToPrivateStorage(message, uri);
 369					if (conversation.getNextEncryption(forceEncryption()) == Message.ENCRYPTION_PGP) {
 370						getPgpEngine().encrypt(message, callback);
 371					} else {
 372						callback.success(message);
 373					}
 374				} catch (final FileBackend.FileCopyException e) {
 375					callback.error(e.getResId(), message);
 376				}
 377			}
 378		}).start();
 379	}
 380
 381	public Conversation find(Bookmark bookmark) {
 382		return find(bookmark.getAccount(), bookmark.getJid());
 383	}
 384
 385	public Conversation find(final Account account, final Jid jid) {
 386		return find(getConversations(), account, jid);
 387	}
 388
 389	@Override
 390	public int onStartCommand(Intent intent, int flags, int startId) {
 391		if (intent != null && intent.getAction() != null) {
 392			if (intent.getAction().equals(ACTION_MERGE_PHONE_CONTACTS)) {
 393				PhoneHelper.loadPhoneContacts(getApplicationContext(), new ArrayList<Bundle>(), this);
 394				return START_STICKY;
 395			} else if (intent.getAction().equals(Intent.ACTION_SHUTDOWN)) {
 396				logoutAndSave();
 397				return START_NOT_STICKY;
 398			} else if (intent.getAction().equals(ACTION_CLEAR_NOTIFICATION)) {
 399				mNotificationService.clear();
 400			} else if (intent.getAction().equals(ACTION_DISABLE_FOREGROUND)) {
 401				getPreferences().edit().putBoolean("keep_foreground_service",false).commit();
 402				toggleForegroundService();
 403			}
 404		}
 405		this.wakeLock.acquire();
 406
 407		for (Account account : accounts) {
 408			if (!account.isOptionSet(Account.OPTION_DISABLED)) {
 409				if (!hasInternetConnection()) {
 410					account.setStatus(Account.State.NO_INTERNET);
 411					if (statusListener != null) {
 412						statusListener.onStatusChanged(account);
 413					}
 414				} else {
 415					if (account.getStatus() == Account.State.NO_INTERNET) {
 416						account.setStatus(Account.State.OFFLINE);
 417						if (statusListener != null) {
 418							statusListener.onStatusChanged(account);
 419						}
 420					}
 421					if (account.getStatus() == Account.State.ONLINE) {
 422						long lastReceived = account.getXmppConnection()
 423							.getLastPacketReceived();
 424						long lastSent = account.getXmppConnection()
 425							.getLastPingSent();
 426						if (lastSent - lastReceived >= Config.PING_TIMEOUT * 1000) {
 427							Log.d(Config.LOGTAG, account.getJid()
 428									+ ": ping timeout");
 429							this.reconnectAccount(account, true);
 430						} else if (SystemClock.elapsedRealtime() - lastReceived >= Config.PING_MIN_INTERVAL * 1000) {
 431							account.getXmppConnection().sendPing();
 432							this.scheduleWakeupCall(2, false);
 433						}
 434					} else if (account.getStatus() == Account.State.OFFLINE) {
 435						if (account.getXmppConnection() == null) {
 436							account.setXmppConnection(this
 437									.createConnection(account));
 438						}
 439						new Thread(account.getXmppConnection()).start();
 440					} else if ((account.getStatus() == Account.State.CONNECTING)
 441							&& ((SystemClock.elapsedRealtime() - account
 442									.getXmppConnection().getLastConnect()) / 1000 >= Config.CONNECT_TIMEOUT)) {
 443						Log.d(Config.LOGTAG, account.getJid()
 444								+ ": time out during connect reconnecting");
 445						reconnectAccount(account, true);
 446					} else {
 447						if (account.getXmppConnection().getTimeToNextAttempt() <= 0) {
 448							reconnectAccount(account, true);
 449						}
 450					}
 451					// in any case. reschedule wakup call
 452					this.scheduleWakeupCall(Config.PING_MAX_INTERVAL, true);
 453				}
 454				if (mOnAccountUpdate != null) {
 455					mOnAccountUpdate.onAccountUpdate();
 456				}
 457			}
 458		}
 459		/*PowerManager pm = (PowerManager) this.getSystemService(Context.POWER_SERVICE);
 460			if (!pm.isScreenOn()) {
 461			removeStaleListeners();
 462			}*/
 463		if (wakeLock.isHeld()) {
 464			try {
 465				wakeLock.release();
 466			} catch (final RuntimeException ignored) {
 467			}
 468		}
 469		return START_STICKY;
 470	}
 471
 472	public boolean hasInternetConnection() {
 473		ConnectivityManager cm = (ConnectivityManager) getApplicationContext()
 474			.getSystemService(Context.CONNECTIVITY_SERVICE);
 475		NetworkInfo activeNetwork = cm.getActiveNetworkInfo();
 476		return activeNetwork != null && activeNetwork.isConnected();
 477	}
 478
 479	@SuppressLint("TrulyRandom")
 480	@Override
 481	public void onCreate() {
 482		ExceptionHelper.init(getApplicationContext());
 483		PRNGFixes.apply();
 484		this.mRandom = new SecureRandom();
 485		this.mMemorizingTrustManager = new MemorizingTrustManager(
 486				getApplicationContext());
 487
 488		final int maxMemory = (int) (Runtime.getRuntime().maxMemory() / 1024);
 489		final int cacheSize = maxMemory / 8;
 490		this.mBitmapCache = new LruCache<String, Bitmap>(cacheSize) {
 491			@Override
 492			protected int sizeOf(final String key, final Bitmap bitmap) {
 493				return bitmap.getByteCount() / 1024;
 494			}
 495		};
 496
 497		this.databaseBackend = DatabaseBackend.getInstance(getApplicationContext());
 498		this.accounts = databaseBackend.getAccounts();
 499
 500		for (final Account account : this.accounts) {
 501			account.initOtrEngine(this);
 502			this.databaseBackend.readRoster(account.getRoster());
 503		}
 504		initConversations();
 505		PhoneHelper.loadPhoneContacts(getApplicationContext(),new ArrayList<Bundle>(), this);
 506
 507		getContentResolver().registerContentObserver(ContactsContract.Contacts.CONTENT_URI, true, contactObserver);
 508		this.fileObserver.startWatching();
 509		this.pgpServiceConnection = new OpenPgpServiceConnection(getApplicationContext(), "org.sufficientlysecure.keychain");
 510		this.pgpServiceConnection.bindToService();
 511
 512		this.pm = (PowerManager) getSystemService(Context.POWER_SERVICE);
 513		this.wakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK,"XmppConnectionService");
 514		toggleForegroundService();
 515	}
 516
 517	public void toggleForegroundService() {
 518		if (getPreferences().getBoolean("keep_foreground_service",false)) {
 519			startForeground(NotificationService.FOREGROUND_NOTIFICATION_ID, this.mNotificationService.createForegroundNotification());
 520		} else {
 521			stopForeground(true);
 522		}
 523	}
 524
 525	@Override
 526	public void onTaskRemoved(final Intent rootIntent) {
 527		super.onTaskRemoved(rootIntent);
 528		if (!getPreferences().getBoolean("keep_foreground_service",false)) {
 529			this.logoutAndSave();
 530		}
 531	}
 532
 533	private void logoutAndSave() {
 534		for (final Account account : accounts) {
 535			databaseBackend.writeRoster(account.getRoster());
 536			if (account.getXmppConnection() != null) {
 537				disconnect(account, false);
 538			}
 539		}
 540		Context context = getApplicationContext();
 541		AlarmManager alarmManager = (AlarmManager) context
 542			.getSystemService(Context.ALARM_SERVICE);
 543		Intent intent = new Intent(context, EventReceiver.class);
 544		alarmManager.cancel(PendingIntent.getBroadcast(context, 0, intent, 0));
 545		Log.d(Config.LOGTAG, "good bye");
 546		stopSelf();
 547	}
 548
 549	protected void scheduleWakeupCall(int seconds, boolean ping) {
 550		long timeToWake = SystemClock.elapsedRealtime() + seconds * 1000;
 551		Context context = getApplicationContext();
 552		AlarmManager alarmManager = (AlarmManager) context
 553			.getSystemService(Context.ALARM_SERVICE);
 554
 555		if (ping) {
 556			if (this.pingIntent == null) {
 557				this.pingIntent = new Intent(context, EventReceiver.class);
 558				this.pingIntent.setAction("ping");
 559				this.pingIntent.putExtra("time", timeToWake);
 560				this.pendingPingIntent = PendingIntent.getBroadcast(context, 0,
 561						this.pingIntent, 0);
 562				alarmManager.set(AlarmManager.ELAPSED_REALTIME_WAKEUP,
 563						timeToWake, pendingPingIntent);
 564			} else {
 565				long scheduledTime = this.pingIntent.getLongExtra("time", 0);
 566				if (scheduledTime < SystemClock.elapsedRealtime()
 567						|| (scheduledTime > timeToWake)) {
 568					this.pingIntent.putExtra("time", timeToWake);
 569					alarmManager.cancel(this.pendingPingIntent);
 570					this.pendingPingIntent = PendingIntent.getBroadcast(
 571							context, 0, this.pingIntent, 0);
 572					alarmManager.set(AlarmManager.ELAPSED_REALTIME_WAKEUP,
 573							timeToWake, pendingPingIntent);
 574						}
 575			}
 576		} else {
 577			Intent intent = new Intent(context, EventReceiver.class);
 578			intent.setAction("ping_check");
 579			PendingIntent alarmIntent = PendingIntent.getBroadcast(context, 0,
 580					intent, 0);
 581			alarmManager.set(AlarmManager.ELAPSED_REALTIME_WAKEUP, timeToWake,
 582					alarmIntent);
 583		}
 584
 585	}
 586
 587	public XmppConnection createConnection(final Account account) {
 588		final SharedPreferences sharedPref = getPreferences();
 589		account.setResource(sharedPref.getString("resource", "mobile")
 590				.toLowerCase(Locale.getDefault()));
 591		final XmppConnection connection = new XmppConnection(account, this);
 592		connection.setOnMessagePacketReceivedListener(this.mMessageParser);
 593		connection.setOnStatusChangedListener(this.statusListener);
 594		connection.setOnPresencePacketReceivedListener(this.mPresenceParser);
 595		connection.setOnUnregisteredIqPacketReceivedListener(this.mIqParser);
 596		connection.setOnJinglePacketReceivedListener(this.jingleListener);
 597		connection.setOnBindListener(this.mOnBindListener);
 598		connection.setOnMessageAcknowledgeListener(this.mOnMessageAcknowledgedListener);
 599		connection.addOnAdvancedStreamFeaturesAvailableListener(this.mMessageArchiveService);
 600		return connection;
 601	}
 602
 603	public void sendMessage(final Message message) {
 604		final Account account = message.getConversation().getAccount();
 605		account.deactivateGracePeriod();
 606		final Conversation conv = message.getConversation();
 607		MessagePacket packet = null;
 608		boolean saveInDb = true;
 609		boolean send = false;
 610		if (account.getStatus() == Account.State.ONLINE
 611				&& account.getXmppConnection() != null) {
 612			if (message.getType() == Message.TYPE_IMAGE || message.getType() == Message.TYPE_FILE) {
 613				if (message.getCounterpart() != null) {
 614					if (message.getEncryption() == Message.ENCRYPTION_OTR) {
 615						if (!conv.hasValidOtrSession()) {
 616							conv.startOtrSession(message.getCounterpart().getResourcepart(),true);
 617							message.setStatus(Message.STATUS_WAITING);
 618						} else if (conv.hasValidOtrSession()
 619								&& conv.getOtrSession().getSessionStatus() == SessionStatus.ENCRYPTED) {
 620							mJingleConnectionManager
 621								.createNewConnection(message);
 622								}
 623					} else {
 624						mJingleConnectionManager.createNewConnection(message);
 625					}
 626				} else {
 627					if (message.getEncryption() == Message.ENCRYPTION_OTR) {
 628						conv.startOtrIfNeeded();
 629					}
 630					message.setStatus(Message.STATUS_WAITING);
 631				}
 632			} else {
 633				if (message.getEncryption() == Message.ENCRYPTION_OTR) {
 634					if (!conv.hasValidOtrSession() && (message.getCounterpart() != null)) {
 635						conv.startOtrSession(message.getCounterpart().getResourcepart(), true);
 636						message.setStatus(Message.STATUS_WAITING);
 637					} else if (conv.hasValidOtrSession()) {
 638						if (conv.getOtrSession().getSessionStatus() == SessionStatus.ENCRYPTED) {
 639							packet = mMessageGenerator.generateOtrChat(message);
 640							send = true;
 641						} else {
 642							message.setStatus(Message.STATUS_WAITING);
 643							conv.startOtrIfNeeded();
 644						}
 645					} else {
 646						message.setStatus(Message.STATUS_WAITING);
 647					}
 648				} else if (message.getEncryption() == Message.ENCRYPTION_DECRYPTED) {
 649					message.getConversation().endOtrIfNeeded();
 650					message.getConversation().findUnsentMessagesWithOtrEncryption(new Conversation.OnMessageFound() {
 651						@Override
 652						public void onMessageFound(Message message) {
 653							markMessage(message,Message.STATUS_SEND_FAILED);
 654						}
 655					});
 656					packet = mMessageGenerator.generatePgpChat(message);
 657					send = true;
 658				} else {
 659					message.getConversation().endOtrIfNeeded();
 660					message.getConversation().findUnsentMessagesWithOtrEncryption(new Conversation.OnMessageFound() {
 661						@Override
 662						public void onMessageFound(Message message) {
 663							markMessage(message,Message.STATUS_SEND_FAILED);
 664						}
 665					});
 666					packet = mMessageGenerator.generateChat(message);
 667					send = true;
 668				}
 669			}
 670			if (!account.getXmppConnection().getFeatures().sm()
 671					&& conv.getMode() != Conversation.MODE_MULTI) {
 672				message.setStatus(Message.STATUS_SEND);
 673					}
 674		} else {
 675			message.setStatus(Message.STATUS_WAITING);
 676			if (message.getType() == Message.TYPE_TEXT) {
 677				if (message.getEncryption() == Message.ENCRYPTION_DECRYPTED) {
 678					String pgpBody = message.getEncryptedBody();
 679					String decryptedBody = message.getBody();
 680					message.setBody(pgpBody);
 681					message.setEncryption(Message.ENCRYPTION_PGP);
 682					databaseBackend.createMessage(message);
 683					saveInDb = false;
 684					message.setBody(decryptedBody);
 685					message.setEncryption(Message.ENCRYPTION_DECRYPTED);
 686				} else if (message.getEncryption() == Message.ENCRYPTION_OTR) {
 687					if (!conv.hasValidOtrSession()
 688							&& message.getCounterpart() != null) {
 689						conv.startOtrSession(message.getCounterpart().getResourcepart(), false);
 690							}
 691				}
 692			}
 693
 694		}
 695		conv.add(message);
 696		if (saveInDb) {
 697			if (message.getEncryption() == Message.ENCRYPTION_NONE
 698					|| saveEncryptedMessages()) {
 699				databaseBackend.createMessage(message);
 700					}
 701		}
 702		if ((send) && (packet != null)) {
 703			sendMessagePacket(account, packet);
 704		}
 705		updateConversationUi();
 706	}
 707
 708	private void sendUnsentMessages(final Conversation conversation) {
 709		conversation.findWaitingMessages(new Conversation.OnMessageFound() {
 710
 711			@Override
 712			public void onMessageFound(Message message) {
 713				resendMessage(message);
 714			}
 715		});
 716	}
 717
 718	private void resendMessage(final Message message) {
 719		Account account = message.getConversation().getAccount();
 720		MessagePacket packet = null;
 721		if (message.getEncryption() == Message.ENCRYPTION_OTR) {
 722			Presences presences = message.getConversation().getContact()
 723				.getPresences();
 724			if (!message.getConversation().hasValidOtrSession()) {
 725				if ((message.getCounterpart() != null)
 726						&& (presences.has(message.getCounterpart().getResourcepart()))) {
 727					message.getConversation().startOtrSession(message.getCounterpart().getResourcepart(), true);
 728				} else {
 729					if (presences.size() == 1) {
 730						String presence = presences.asStringArray()[0];
 731						message.getConversation().startOtrSession(presence, true);
 732					}
 733				}
 734			} else {
 735				if (message.getConversation().getOtrSession()
 736						.getSessionStatus() == SessionStatus.ENCRYPTED) {
 737					try {
 738						message.setCounterpart(Jid.fromSessionID(message.getConversation().getOtrSession().getSessionID()));
 739						if (message.getType() == Message.TYPE_TEXT) {
 740							packet = mMessageGenerator.generateOtrChat(message,
 741									true);
 742						} else if (message.getType() == Message.TYPE_IMAGE || message.getType() == Message.TYPE_FILE) {
 743							mJingleConnectionManager.createNewConnection(message);
 744						}
 745					} catch (final InvalidJidException ignored) {
 746
 747					}
 748						}
 749			}
 750		} else if (message.getType() == Message.TYPE_TEXT) {
 751			if (message.getEncryption() == Message.ENCRYPTION_NONE) {
 752				packet = mMessageGenerator.generateChat(message, true);
 753			} else if ((message.getEncryption() == Message.ENCRYPTION_DECRYPTED)
 754					|| (message.getEncryption() == Message.ENCRYPTION_PGP)) {
 755				packet = mMessageGenerator.generatePgpChat(message, true);
 756					}
 757		} else if (message.getType() == Message.TYPE_IMAGE || message.getType() == Message.TYPE_FILE) {
 758			Contact contact = message.getConversation().getContact();
 759			Presences presences = contact.getPresences();
 760			if ((message.getCounterpart() != null)
 761					&& (presences.has(message.getCounterpart().getResourcepart()))) {
 762				markMessage(message, Message.STATUS_OFFERED);
 763				mJingleConnectionManager.createNewConnection(message);
 764			} else {
 765				if (presences.size() == 1) {
 766					String presence = presences.asStringArray()[0];
 767					try {
 768						message.setCounterpart(Jid.fromParts(contact.getJid().getLocalpart(), contact.getJid().getDomainpart(), presence));
 769					} catch (InvalidJidException e) {
 770						return;
 771					}
 772					markMessage(message, Message.STATUS_OFFERED);
 773					mJingleConnectionManager.createNewConnection(message);
 774				}
 775			}
 776		}
 777		if (packet != null) {
 778			if (!account.getXmppConnection().getFeatures().sm()
 779					&& message.getConversation().getMode() != Conversation.MODE_MULTI) {
 780				markMessage(message, Message.STATUS_SEND);
 781			} else {
 782				markMessage(message, Message.STATUS_UNSEND);
 783			}
 784			sendMessagePacket(account, packet);
 785		}
 786	}
 787
 788	public void fetchRosterFromServer(final Account account) {
 789		final IqPacket iqPacket = new IqPacket(IqPacket.TYPE.GET);
 790		if (!"".equals(account.getRosterVersion())) {
 791			Log.d(Config.LOGTAG, account.getJid().toBareJid()
 792					+ ": fetching roster version " + account.getRosterVersion());
 793		} else {
 794			Log.d(Config.LOGTAG, account.getJid().toBareJid() + ": fetching roster");
 795		}
 796		iqPacket.query(Xmlns.ROSTER).setAttribute("ver",
 797				account.getRosterVersion());
 798		account.getXmppConnection().sendIqPacket(iqPacket, mIqParser);
 799	}
 800
 801	public void fetchBookmarks(final Account account) {
 802		final IqPacket iqPacket = new IqPacket(IqPacket.TYPE.GET);
 803		final Element query = iqPacket.query("jabber:iq:private");
 804		query.addChild("storage", "storage:bookmarks");
 805		final OnIqPacketReceived callback = new OnIqPacketReceived() {
 806
 807			@Override
 808			public void onIqPacketReceived(final Account account, final IqPacket packet) {
 809				final Element query = packet.query();
 810				final List<Bookmark> bookmarks = new CopyOnWriteArrayList<>();
 811				final Element storage = query.findChild("storage",
 812						"storage:bookmarks");
 813				if (storage != null) {
 814					for (final Element item : storage.getChildren()) {
 815						if (item.getName().equals("conference")) {
 816							final Bookmark bookmark = Bookmark.parse(item, account);
 817							bookmarks.add(bookmark);
 818							Conversation conversation = find(bookmark);
 819							if (conversation != null) {
 820								conversation.setBookmark(bookmark);
 821							} else if (bookmark.autojoin() && bookmark.getJid() != null) {
 822								conversation = findOrCreateConversation(
 823										account, bookmark.getJid(), true);
 824								conversation.setBookmark(bookmark);
 825								joinMuc(conversation);
 826							}
 827						}
 828					}
 829				}
 830				account.setBookmarks(bookmarks);
 831			}
 832		};
 833		sendIqPacket(account, iqPacket, callback);
 834	}
 835
 836	public void pushBookmarks(Account account) {
 837		IqPacket iqPacket = new IqPacket(IqPacket.TYPE.SET);
 838		Element query = iqPacket.query("jabber:iq:private");
 839		Element storage = query.addChild("storage", "storage:bookmarks");
 840		for (Bookmark bookmark : account.getBookmarks()) {
 841			storage.addChild(bookmark);
 842		}
 843		sendIqPacket(account, iqPacket, null);
 844	}
 845
 846	public void onPhoneContactsLoaded(final List<Bundle> phoneContacts) {
 847		if (mPhoneContactMergerThread != null) {
 848			mPhoneContactMergerThread.interrupt();
 849		}
 850		mPhoneContactMergerThread = new Thread(new Runnable() {
 851			@Override
 852			public void run() {
 853				Log.d(Config.LOGTAG,"start merging phone contacts with roster");
 854				for (Account account : accounts) {
 855					account.getRoster().clearSystemAccounts();
 856					for (Bundle phoneContact : phoneContacts) {
 857						if (Thread.interrupted()) {
 858							Log.d(Config.LOGTAG,"interrupted merging phone contacts");
 859							return;
 860						}
 861						Jid jid;
 862						try {
 863							jid = Jid.fromString(phoneContact.getString("jid"));
 864						} catch (final InvalidJidException e) {
 865							continue;
 866						}
 867						final Contact contact = account.getRoster().getContact(jid);
 868						String systemAccount = phoneContact.getInt("phoneid")
 869							+ "#"
 870							+ phoneContact.getString("lookup");
 871						contact.setSystemAccount(systemAccount);
 872						contact.setPhotoUri(phoneContact.getString("photouri"));
 873						getAvatarService().clear(contact);
 874						contact.setSystemName(phoneContact.getString("displayname"));
 875					}
 876				}
 877				Log.d(Config.LOGTAG,"finished merging phone contacts");
 878				updateAccountUi();
 879			}
 880		});
 881		mPhoneContactMergerThread.start();
 882	}
 883
 884	private void initConversations() {
 885		synchronized (this.conversations) {
 886			final Map<String, Account> accountLookupTable = new Hashtable<>();
 887			for (Account account : this.accounts) {
 888				accountLookupTable.put(account.getUuid(), account);
 889			}
 890			this.conversations.addAll(databaseBackend.getConversations(Conversation.STATUS_AVAILABLE));
 891			for (Conversation conversation : this.conversations) {
 892				Account account = accountLookupTable.get(conversation.getAccountUuid());
 893				conversation.setAccount(account);
 894				conversation.addAll(0, databaseBackend.getMessages(conversation, Config.PAGE_SIZE));
 895				checkDeletedFiles(conversation);
 896			}
 897		}
 898	}
 899
 900	public List<Conversation> getConversations() {
 901		return this.conversations;
 902	}
 903
 904	private void checkDeletedFiles(Conversation conversation) {
 905		conversation.findMessagesWithFiles(new Conversation.OnMessageFound() {
 906
 907			@Override
 908			public void onMessageFound(Message message) {
 909				if (!getFileBackend().isFileAvailable(message)) {
 910					message.setDownloadable(new DownloadablePlaceholder(Downloadable.STATUS_DELETED));
 911				}
 912			}
 913		});
 914	}
 915
 916	private void markFileDeleted(String uuid) {
 917		for (Conversation conversation : getConversations()) {
 918			Message message = conversation.findMessageWithFileAndUuid(uuid);
 919			if (message != null) {
 920				if (!getFileBackend().isFileAvailable(message)) {
 921					message.setDownloadable(new DownloadablePlaceholder(Downloadable.STATUS_DELETED));
 922					updateConversationUi();
 923				}
 924				return;
 925			}
 926		}
 927	}
 928
 929	public void populateWithOrderedConversations(final List<Conversation> list) {
 930		populateWithOrderedConversations(list, true);
 931	}
 932
 933	public void populateWithOrderedConversations(final List<Conversation> list, boolean includeConferences) {
 934		list.clear();
 935		if (includeConferences) {
 936			list.addAll(getConversations());
 937		} else {
 938			for (Conversation conversation : getConversations()) {
 939				if (conversation.getMode() == Conversation.MODE_SINGLE) {
 940					list.add(conversation);
 941				}
 942			}
 943		}
 944		Collections.sort(list, new Comparator<Conversation>() {
 945			@Override
 946			public int compare(Conversation lhs, Conversation rhs) {
 947				Message left = lhs.getLatestMessage();
 948				Message right = rhs.getLatestMessage();
 949				if (left.getTimeSent() > right.getTimeSent()) {
 950					return -1;
 951				} else if (left.getTimeSent() < right.getTimeSent()) {
 952					return 1;
 953				} else {
 954					return 0;
 955				}
 956			}
 957		});
 958	}
 959
 960	public void loadMoreMessages(final Conversation conversation, final long timestamp, final OnMoreMessagesLoaded callback) {
 961		Log.d(Config.LOGTAG,"load more messages for "+conversation.getName() + " prior to "+MessageGenerator.getTimestamp(timestamp));
 962		if (XmppConnectionService.this.getMessageArchiveService().queryInProgress(conversation,callback)) {
 963			return;
 964		}
 965		new Thread(new Runnable() {
 966			@Override
 967			public void run() {
 968				final Account account = conversation.getAccount();
 969				List<Message> messages = databaseBackend.getMessages(conversation, 50,timestamp);
 970				if (messages.size() > 0) {
 971					conversation.addAll(0, messages);
 972					callback.onMoreMessagesLoaded(messages.size(), conversation);
 973				} else if (conversation.hasMessagesLeftOnServer()
 974						&& account.isOnlineAndConnected()
 975						&& account.getXmppConnection().getFeatures().mam()) {
 976					MessageArchiveService.Query query = getMessageArchiveService().query(conversation,0,timestamp - 1);
 977					if (query != null) {
 978						query.setCallback(callback);
 979					}
 980					callback.informUser(R.string.fetching_history_from_server);
 981						}
 982			}
 983		}).start();
 984	}
 985
 986	public interface OnMoreMessagesLoaded {
 987		public void onMoreMessagesLoaded(int count,Conversation conversation);
 988		public void informUser(int r);
 989	}
 990
 991	public List<Account> getAccounts() {
 992		return this.accounts;
 993	}
 994
 995	public Conversation find(final Iterable<Conversation> haystack, final Contact contact) {
 996		for (final Conversation conversation : haystack) {
 997			if (conversation.getContact() == contact) {
 998				return conversation;
 999			}
1000		}
1001		return null;
1002	}
1003
1004	public Conversation find(final Iterable<Conversation> haystack, final Account account, final Jid jid) {
1005		if (jid == null ) {
1006			return null;
1007		}
1008		for (final Conversation conversation : haystack) {
1009			if ((account == null || conversation.getAccount() == account)
1010					&& (conversation.getJid().toBareJid().equals(jid.toBareJid()))) {
1011				return conversation;
1012					}
1013		}
1014		return null;
1015	}
1016
1017	public Conversation findOrCreateConversation(final Account account, final Jid jid,final boolean muc) {
1018		return this.findOrCreateConversation(account,jid,muc,null);
1019	}
1020
1021	public Conversation findOrCreateConversation(final Account account, final Jid jid,final boolean muc, final MessageArchiveService.Query query) {
1022		synchronized (this.conversations) {
1023			Conversation conversation = find(account, jid);
1024			if (conversation != null) {
1025				return conversation;
1026			}
1027			conversation = databaseBackend.findConversation(account, jid);
1028			if (conversation != null) {
1029				conversation.setStatus(Conversation.STATUS_AVAILABLE);
1030				conversation.setAccount(account);
1031				if (muc) {
1032					conversation.setMode(Conversation.MODE_MULTI);
1033				} else {
1034					conversation.setMode(Conversation.MODE_SINGLE);
1035				}
1036				conversation.addAll(0, databaseBackend.getMessages(conversation, Config.PAGE_SIZE));
1037				this.databaseBackend.updateConversation(conversation);
1038			} else {
1039				String conversationName;
1040				Contact contact = account.getRoster().getContact(jid);
1041				if (contact != null) {
1042					conversationName = contact.getDisplayName();
1043				} else {
1044					conversationName = jid.getLocalpart();
1045				}
1046				if (muc) {
1047					conversation = new Conversation(conversationName, account, jid,
1048							Conversation.MODE_MULTI);
1049				} else {
1050					conversation = new Conversation(conversationName, account, jid,
1051							Conversation.MODE_SINGLE);
1052				}
1053				this.databaseBackend.createConversation(conversation);
1054			}
1055			if (query == null) {
1056				this.mMessageArchiveService.query(conversation);
1057			} else {
1058				if (query.getConversation() == null) {
1059					this.mMessageArchiveService.query(conversation,query.getStart());
1060				}
1061			}
1062			this.conversations.add(conversation);
1063			updateConversationUi();
1064			return conversation;
1065		}
1066	}
1067
1068	public void archiveConversation(Conversation conversation) {
1069		synchronized (this.conversations) {
1070			if (conversation.getMode() == Conversation.MODE_MULTI) {
1071				if (conversation.getAccount().getStatus() == Account.State.ONLINE) {
1072					Bookmark bookmark = conversation.getBookmark();
1073					if (bookmark != null && bookmark.autojoin()) {
1074						bookmark.setAutojoin(false);
1075						pushBookmarks(bookmark.getAccount());
1076					}
1077				}
1078				leaveMuc(conversation);
1079			} else {
1080				conversation.endOtrIfNeeded();
1081			}
1082			this.databaseBackend.updateConversation(conversation);
1083			this.conversations.remove(conversation);
1084			updateConversationUi();
1085		}
1086	}
1087
1088	public void createAccount(final Account account) {
1089		account.initOtrEngine(this);
1090		databaseBackend.createAccount(account);
1091		this.accounts.add(account);
1092		this.reconnectAccount(account, false);
1093		updateAccountUi();
1094	}
1095
1096	public void updateAccount(final Account account) {
1097		this.statusListener.onStatusChanged(account);
1098		databaseBackend.updateAccount(account);
1099		reconnectAccount(account, false);
1100		updateAccountUi();
1101		getNotificationService().updateErrorNotification();
1102	}
1103
1104	public void updateAccountPasswordOnServer(final Account account, final String newPassword, final OnAccountPasswordChanged callback) {
1105		final IqPacket iq = getIqGenerator().generateSetPassword(account, newPassword);
1106		sendIqPacket(account, iq, new OnIqPacketReceived() {
1107			@Override
1108			public void onIqPacketReceived(final Account account, final IqPacket packet) {
1109				if (packet.getType() == IqPacket.TYPE.RESULT) {
1110					account.setPassword(newPassword);
1111					databaseBackend.updateAccount(account);
1112					callback.onPasswordChangeSucceeded();
1113				} else {
1114					callback.onPasswordChangeFailed();
1115				}
1116			}
1117		});
1118	}
1119
1120	public interface OnAccountPasswordChanged {
1121		public void onPasswordChangeSucceeded();
1122		public void onPasswordChangeFailed();
1123	}
1124
1125	public void deleteAccount(final Account account) {
1126		synchronized (this.conversations) {
1127			for (final Conversation conversation : conversations) {
1128				if (conversation.getAccount() == account) {
1129					if (conversation.getMode() == Conversation.MODE_MULTI) {
1130						leaveMuc(conversation);
1131					} else if (conversation.getMode() == Conversation.MODE_SINGLE) {
1132						conversation.endOtrIfNeeded();
1133					}
1134					conversations.remove(conversation);
1135				}
1136			}
1137			if (account.getXmppConnection() != null) {
1138				this.disconnect(account, true);
1139			}
1140			databaseBackend.deleteAccount(account);
1141			this.accounts.remove(account);
1142			updateAccountUi();
1143			getNotificationService().updateErrorNotification();
1144		}
1145	}
1146
1147	public void setOnConversationListChangedListener(OnConversationUpdate listener) {
1148		synchronized (this) {
1149			if (checkListeners()) {
1150				switchToForeground();
1151			}
1152			this.mOnConversationUpdate = listener;
1153			this.mNotificationService.setIsInForeground(true);
1154			if (this.convChangedListenerCount < 2) {
1155				this.convChangedListenerCount++;
1156			}
1157		}
1158	}
1159
1160	public void removeOnConversationListChangedListener() {
1161		synchronized (this) {
1162			this.convChangedListenerCount--;
1163			if (this.convChangedListenerCount <= 0) {
1164				this.convChangedListenerCount = 0;
1165				this.mOnConversationUpdate = null;
1166				this.mNotificationService.setIsInForeground(false);
1167				if (checkListeners()) {
1168					switchToBackground();
1169				}
1170			}
1171		}
1172	}
1173
1174	public void setOnAccountListChangedListener(OnAccountUpdate listener) {
1175		synchronized (this) {
1176			if (checkListeners()) {
1177				switchToForeground();
1178			}
1179			this.mOnAccountUpdate = listener;
1180			if (this.accountChangedListenerCount < 2) {
1181				this.accountChangedListenerCount++;
1182			}
1183		}
1184	}
1185
1186	public void removeOnAccountListChangedListener() {
1187		synchronized (this) {
1188			this.accountChangedListenerCount--;
1189			if (this.accountChangedListenerCount <= 0) {
1190				this.mOnAccountUpdate = null;
1191				this.accountChangedListenerCount = 0;
1192				if (checkListeners()) {
1193					switchToBackground();
1194				}
1195			}
1196		}
1197	}
1198
1199	public void setOnRosterUpdateListener(final OnRosterUpdate listener) {
1200		synchronized (this) {
1201			if (checkListeners()) {
1202				switchToForeground();
1203			}
1204			this.mOnRosterUpdate = listener;
1205			if (this.rosterChangedListenerCount < 2) {
1206				this.rosterChangedListenerCount++;
1207			}
1208		}
1209	}
1210
1211	public void removeOnRosterUpdateListener() {
1212		synchronized (this) {
1213			this.rosterChangedListenerCount--;
1214			if (this.rosterChangedListenerCount <= 0) {
1215				this.rosterChangedListenerCount = 0;
1216				this.mOnRosterUpdate = null;
1217				if (checkListeners()) {
1218					switchToBackground();
1219				}
1220			}
1221		}
1222	}
1223
1224	public void setOnUpdateBlocklistListener(final OnUpdateBlocklist listener) {
1225		synchronized (this) {
1226			if (checkListeners()) {
1227				switchToForeground();
1228			}
1229			this.mOnUpdateBlocklist = listener;
1230			if (this.updateBlocklistListenerCount < 2) {
1231				this.updateBlocklistListenerCount++;
1232			}
1233		}
1234	}
1235
1236	public void removeOnUpdateBlocklistListener() {
1237		synchronized (this) {
1238			this.updateBlocklistListenerCount--;
1239			if (this.updateBlocklistListenerCount <= 0) {
1240				this.updateBlocklistListenerCount = 0;
1241				this.mOnUpdateBlocklist = null;
1242				if (checkListeners()) {
1243					switchToBackground();
1244				}
1245			}
1246		}
1247	}
1248
1249	public void setOnMucRosterUpdateListener(OnMucRosterUpdate listener) {
1250		synchronized (this) {
1251			if (checkListeners()) {
1252				switchToForeground();
1253			}
1254			this.mOnMucRosterUpdate = listener;
1255			if (this.mucRosterChangedListenerCount < 2) {
1256				this.mucRosterChangedListenerCount++;
1257			}
1258		}
1259	}
1260
1261	public void removeOnMucRosterUpdateListener() {
1262		synchronized (this) {
1263			this.mucRosterChangedListenerCount--;
1264			if (this.mucRosterChangedListenerCount <= 0) {
1265				this.mucRosterChangedListenerCount = 0;
1266				this.mOnMucRosterUpdate = null;
1267				if (checkListeners()) {
1268					switchToBackground();
1269				}
1270			}
1271		}
1272	}
1273
1274	private boolean checkListeners() {
1275		return (this.mOnAccountUpdate == null
1276				&& this.mOnConversationUpdate == null
1277				&& this.mOnRosterUpdate == null
1278				&& this.mOnUpdateBlocklist == null);
1279	}
1280
1281	private void switchToForeground() {
1282		for (Account account : getAccounts()) {
1283			if (account.getStatus() == Account.State.ONLINE) {
1284				XmppConnection connection = account.getXmppConnection();
1285				if (connection != null && connection.getFeatures().csi()) {
1286					connection.sendActive();
1287				}
1288			}
1289		}
1290		Log.d(Config.LOGTAG, "app switched into foreground");
1291	}
1292
1293	private void switchToBackground() {
1294		for (Account account : getAccounts()) {
1295			if (account.getStatus() == Account.State.ONLINE) {
1296				XmppConnection connection = account.getXmppConnection();
1297				if (connection != null && connection.getFeatures().csi()) {
1298					connection.sendInactive();
1299				}
1300			}
1301		}
1302		this.mNotificationService.setIsInForeground(false);
1303		Log.d(Config.LOGTAG, "app switched into background");
1304	}
1305
1306	private void connectMultiModeConversations(Account account) {
1307		List<Conversation> conversations = getConversations();
1308		for (Conversation conversation : conversations) {
1309			if ((conversation.getMode() == Conversation.MODE_MULTI)
1310					&& (conversation.getAccount() == account)) {
1311				conversation.resetMucOptions();
1312				joinMuc(conversation);
1313					}
1314		}
1315	}
1316
1317	public void joinMuc(Conversation conversation) {
1318		Account account = conversation.getAccount();
1319		account.pendingConferenceJoins.remove(conversation);
1320		account.pendingConferenceLeaves.remove(conversation);
1321		if (account.getStatus() == Account.State.ONLINE) {
1322			final String nick = conversation.getMucOptions().getProposedNick();
1323			final Jid joinJid = conversation.getMucOptions().createJoinJid(nick);
1324			if (joinJid == null) {
1325				return; //safety net
1326			}
1327			Log.d(Config.LOGTAG, account.getJid().toBareJid().toString() + ": joining conversation " + joinJid.toString());
1328			PresencePacket packet = new PresencePacket();
1329			packet.setFrom(conversation.getAccount().getJid());
1330			packet.setTo(joinJid);
1331			Element x = packet.addChild("x","http://jabber.org/protocol/muc");
1332			if (conversation.getMucOptions().getPassword() != null) {
1333				x.addChild("password").setContent(conversation.getMucOptions().getPassword());
1334			}
1335			x.addChild("history").setAttribute("since",PresenceGenerator.getTimestamp(conversation.getLastMessageTransmitted()));
1336			String sig = account.getPgpSignature();
1337			if (sig != null) {
1338				packet.addChild("status").setContent("online");
1339				packet.addChild("x", "jabber:x:signed").setContent(sig);
1340			}
1341			sendPresencePacket(account, packet);
1342			if (!joinJid.equals(conversation.getJid())) {
1343				conversation.setContactJid(joinJid);
1344				databaseBackend.updateConversation(conversation);
1345			}
1346		} else {
1347			account.pendingConferenceJoins.add(conversation);
1348		}
1349	}
1350
1351	public void providePasswordForMuc(Conversation conversation, String password) {
1352		if (conversation.getMode() == Conversation.MODE_MULTI) {
1353			conversation.getMucOptions().setPassword(password);
1354			if (conversation.getBookmark() != null) {
1355				conversation.getBookmark().setAutojoin(true);
1356				pushBookmarks(conversation.getAccount());
1357			}
1358			databaseBackend.updateConversation(conversation);
1359			joinMuc(conversation);
1360		}
1361	}
1362
1363	public void renameInMuc(final Conversation conversation, final String nick, final UiCallback<Conversation> callback) {
1364		final MucOptions options = conversation.getMucOptions();
1365		final Jid joinJid = options.createJoinJid(nick);
1366		if (options.online()) {
1367			Account account = conversation.getAccount();
1368			options.setOnRenameListener(new OnRenameListener() {
1369
1370				@Override
1371				public void onSuccess() {
1372					conversation.setContactJid(joinJid);
1373					databaseBackend.updateConversation(conversation);
1374					Bookmark bookmark = conversation.getBookmark();
1375					if (bookmark != null) {
1376						bookmark.setNick(nick);
1377						pushBookmarks(bookmark.getAccount());
1378					}
1379					callback.success(conversation);
1380				}
1381
1382				@Override
1383				public void onFailure() {
1384					callback.error(R.string.nick_in_use, conversation);
1385				}
1386			});
1387
1388			PresencePacket packet = new PresencePacket();
1389			packet.setTo(joinJid);
1390			packet.setFrom(conversation.getAccount().getJid());
1391
1392			String sig = account.getPgpSignature();
1393			if (sig != null) {
1394				packet.addChild("status").setContent("online");
1395				packet.addChild("x", "jabber:x:signed").setContent(sig);
1396			}
1397			sendPresencePacket(account, packet);
1398		} else {
1399			conversation.setContactJid(joinJid);
1400			databaseBackend.updateConversation(conversation);
1401			if (conversation.getAccount().getStatus() == Account.State.ONLINE) {
1402				Bookmark bookmark = conversation.getBookmark();
1403				if (bookmark != null) {
1404					bookmark.setNick(nick);
1405					pushBookmarks(bookmark.getAccount());
1406				}
1407				joinMuc(conversation);
1408			}
1409		}
1410	}
1411
1412	public void leaveMuc(Conversation conversation) {
1413		Account account = conversation.getAccount();
1414		account.pendingConferenceJoins.remove(conversation);
1415		account.pendingConferenceLeaves.remove(conversation);
1416		if (account.getStatus() == Account.State.ONLINE) {
1417			PresencePacket packet = new PresencePacket();
1418			packet.setTo(conversation.getJid());
1419			packet.setFrom(conversation.getAccount().getJid());
1420			packet.setAttribute("type", "unavailable");
1421			sendPresencePacket(conversation.getAccount(), packet);
1422			conversation.getMucOptions().setOffline();
1423			conversation.deregisterWithBookmark();
1424			Log.d(Config.LOGTAG, conversation.getAccount().getJid().toBareJid()
1425					+ ": leaving muc " + conversation.getJid());
1426		} else {
1427			account.pendingConferenceLeaves.add(conversation);
1428		}
1429	}
1430
1431	private String findConferenceServer(final Account account) {
1432		String server;
1433		if (account.getXmppConnection() != null) {
1434			server = account.getXmppConnection().getMucServer();
1435			if (server != null) {
1436				return server;
1437			}
1438		}
1439		for(Account other : getAccounts()) {
1440			if (other != account && other.getXmppConnection() != null) {
1441				server = other.getXmppConnection().getMucServer();
1442				if (server != null) {
1443					return server;
1444				}
1445			}
1446		}
1447		return null;
1448	}
1449
1450	public void createAdhocConference(final Account account, final Iterable<Jid> jids, final UiCallback<Conversation> callback) {
1451		Log.d(Config.LOGTAG, account.getJid().toBareJid().toString() + ": creating adhoc conference with " + jids.toString());
1452		if (account.getStatus() == Account.State.ONLINE) {
1453			try {
1454				String server = findConferenceServer(account);
1455				if (server == null) {
1456					if (callback != null) {
1457						callback.error(R.string.no_conference_server_found,null);
1458					}
1459					return;
1460				}
1461				String name = new BigInteger(75,getRNG()).toString(32);
1462				Jid jid = Jid.fromParts(name,server,null);
1463				final Conversation conversation = findOrCreateConversation(account, jid, true);
1464				joinMuc(conversation);
1465				Bundle options = new Bundle();
1466				options.putString("muc#roomconfig_persistentroom", "1");
1467				options.putString("muc#roomconfig_membersonly", "1");
1468				options.putString("muc#roomconfig_publicroom", "0");
1469				options.putString("muc#roomconfig_whois", "anyone");
1470				pushConferenceConfiguration(conversation, options, new OnConferenceOptionsPushed() {
1471					@Override
1472					public void onPushSucceeded() {
1473						for(Jid invite : jids) {
1474							invite(conversation,invite);
1475						}
1476						if (callback != null) {
1477							callback.success(conversation);
1478						}
1479					}
1480
1481					@Override
1482					public void onPushFailed() {
1483						if (callback != null) {
1484							callback.error(R.string.conference_creation_failed, conversation);
1485						}
1486					}
1487				});
1488
1489			} catch (InvalidJidException e) {
1490				if (callback != null) {
1491					callback.error(R.string.conference_creation_failed, null);
1492				}
1493			}
1494		} else {
1495			if (callback != null) {
1496				callback.error(R.string.not_connected_try_again,null);
1497			}
1498		}
1499	}
1500
1501	public void pushConferenceConfiguration(final Conversation conversation,final Bundle options, final OnConferenceOptionsPushed callback) {
1502		IqPacket request = new IqPacket(IqPacket.TYPE.GET);
1503		request.setTo(conversation.getJid().toBareJid());
1504		request.query("http://jabber.org/protocol/muc#owner");
1505		sendIqPacket(conversation.getAccount(),request,new OnIqPacketReceived() {
1506			@Override
1507			public void onIqPacketReceived(Account account, IqPacket packet) {
1508				if (packet.getType() != IqPacket.TYPE.ERROR) {
1509					Data data = Data.parse(packet.query().findChild("x", "jabber:x:data"));
1510					for (Field field : data.getFields()) {
1511						if (options.containsKey(field.getName())) {
1512							field.setValue(options.getString(field.getName()));
1513						}
1514					}
1515					data.submit();
1516					IqPacket set = new IqPacket(IqPacket.TYPE.SET);
1517					set.setTo(conversation.getJid().toBareJid());
1518					set.query("http://jabber.org/protocol/muc#owner").addChild(data);
1519					sendIqPacket(account, set, new OnIqPacketReceived() {
1520						@Override
1521						public void onIqPacketReceived(Account account, IqPacket packet) {
1522							if (packet.getType() == IqPacket.TYPE.RESULT) {
1523								if (callback != null) {
1524									callback.onPushSucceeded();
1525								}
1526							} else {
1527								if (callback != null) {
1528									callback.onPushFailed();
1529								}
1530							}
1531						}
1532					});
1533				} else {
1534					if (callback != null) {
1535						callback.onPushFailed();
1536					}
1537				}
1538			}
1539		});
1540	}
1541
1542	public void disconnect(Account account, boolean force) {
1543		if ((account.getStatus() == Account.State.ONLINE)
1544				|| (account.getStatus() == Account.State.DISABLED)) {
1545			if (!force) {
1546				List<Conversation> conversations = getConversations();
1547				for (Conversation conversation : conversations) {
1548					if (conversation.getAccount() == account) {
1549						if (conversation.getMode() == Conversation.MODE_MULTI) {
1550							leaveMuc(conversation);
1551						} else {
1552							if (conversation.endOtrIfNeeded()) {
1553								Log.d(Config.LOGTAG, account.getJid().toBareJid()
1554										+ ": ended otr session with "
1555										+ conversation.getJid());
1556							}
1557						}
1558					}
1559				}
1560			}
1561			account.getXmppConnection().disconnect(force);
1562				}
1563	}
1564
1565	@Override
1566	public IBinder onBind(Intent intent) {
1567		return mBinder;
1568	}
1569
1570	public void updateMessage(Message message) {
1571		databaseBackend.updateMessage(message);
1572		updateConversationUi();
1573	}
1574
1575	protected void syncDirtyContacts(Account account) {
1576		for (Contact contact : account.getRoster().getContacts()) {
1577			if (contact.getOption(Contact.Options.DIRTY_PUSH)) {
1578				pushContactToServer(contact);
1579			}
1580			if (contact.getOption(Contact.Options.DIRTY_DELETE)) {
1581				deleteContactOnServer(contact);
1582			}
1583		}
1584	}
1585
1586	public void createContact(Contact contact) {
1587		SharedPreferences sharedPref = getPreferences();
1588		boolean autoGrant = sharedPref.getBoolean("grant_new_contacts", true);
1589		if (autoGrant) {
1590			contact.setOption(Contact.Options.PREEMPTIVE_GRANT);
1591			contact.setOption(Contact.Options.ASKING);
1592		}
1593		pushContactToServer(contact);
1594	}
1595
1596	public void onOtrSessionEstablished(Conversation conversation) {
1597		final Account account = conversation.getAccount();
1598		final Session otrSession = conversation.getOtrSession();
1599		Log.d(Config.LOGTAG,
1600				account.getJid().toBareJid() + " otr session established with "
1601				+ conversation.getJid() + "/"
1602				+ otrSession.getSessionID().getUserID());
1603		conversation.findUnsentMessagesWithOtrEncryption(new Conversation.OnMessageFound() {
1604
1605			@Override
1606			public void onMessageFound(Message message) {
1607				SessionID id = otrSession.getSessionID();
1608				try {
1609					message.setCounterpart(Jid.fromString(id.getAccountID() + "/" + id.getUserID()));
1610				} catch (InvalidJidException e) {
1611					return;
1612				}
1613				if (message.getType() == Message.TYPE_TEXT) {
1614					MessagePacket outPacket = mMessageGenerator.generateOtrChat(message, true);
1615					if (outPacket != null) {
1616						message.setStatus(Message.STATUS_SEND);
1617						databaseBackend.updateMessage(message);
1618						sendMessagePacket(account, outPacket);
1619					}
1620				} else if (message.getType() == Message.TYPE_IMAGE || message.getType() == Message.TYPE_FILE) {
1621					mJingleConnectionManager.createNewConnection(message);
1622				}
1623				updateConversationUi();
1624			}
1625		});
1626	}
1627
1628	public boolean renewSymmetricKey(Conversation conversation) {
1629		Account account = conversation.getAccount();
1630		byte[] symmetricKey = new byte[32];
1631		this.mRandom.nextBytes(symmetricKey);
1632		Session otrSession = conversation.getOtrSession();
1633		if (otrSession != null) {
1634			MessagePacket packet = new MessagePacket();
1635			packet.setType(MessagePacket.TYPE_CHAT);
1636			packet.setFrom(account.getJid());
1637			packet.addChild("private", "urn:xmpp:carbons:2");
1638			packet.addChild("no-copy", "urn:xmpp:hints");
1639			packet.setAttribute("to", otrSession.getSessionID().getAccountID() + "/"
1640					+ otrSession.getSessionID().getUserID());
1641			try {
1642				packet.setBody(otrSession
1643						.transformSending(CryptoHelper.FILETRANSFER
1644							+ CryptoHelper.bytesToHex(symmetricKey)));
1645				sendMessagePacket(account, packet);
1646				conversation.setSymmetricKey(symmetricKey);
1647				return true;
1648			} catch (OtrException e) {
1649				return false;
1650			}
1651		}
1652		return false;
1653	}
1654
1655	public void pushContactToServer(final Contact contact) {
1656		contact.resetOption(Contact.Options.DIRTY_DELETE);
1657		contact.setOption(Contact.Options.DIRTY_PUSH);
1658		final Account account = contact.getAccount();
1659		if (account.getStatus() == Account.State.ONLINE) {
1660			final boolean ask = contact.getOption(Contact.Options.ASKING);
1661			final boolean sendUpdates = contact
1662				.getOption(Contact.Options.PENDING_SUBSCRIPTION_REQUEST)
1663				&& contact.getOption(Contact.Options.PREEMPTIVE_GRANT);
1664			final IqPacket iq = new IqPacket(IqPacket.TYPE.SET);
1665			iq.query(Xmlns.ROSTER).addChild(contact.asElement());
1666			account.getXmppConnection().sendIqPacket(iq, null);
1667			if (sendUpdates) {
1668				sendPresencePacket(account,
1669						mPresenceGenerator.sendPresenceUpdatesTo(contact));
1670			}
1671			if (ask) {
1672				sendPresencePacket(account,
1673						mPresenceGenerator.requestPresenceUpdatesFrom(contact));
1674			}
1675		}
1676	}
1677
1678	public void publishAvatar(final Account account,
1679			final Uri image,
1680			final UiCallback<Avatar> callback) {
1681		final Bitmap.CompressFormat format = Config.AVATAR_FORMAT;
1682		final int size = Config.AVATAR_SIZE;
1683		final Avatar avatar = getFileBackend()
1684			.getPepAvatar(image, size, format);
1685		if (avatar != null) {
1686			avatar.height = size;
1687			avatar.width = size;
1688			if (format.equals(Bitmap.CompressFormat.WEBP)) {
1689				avatar.type = "image/webp";
1690			} else if (format.equals(Bitmap.CompressFormat.JPEG)) {
1691				avatar.type = "image/jpeg";
1692			} else if (format.equals(Bitmap.CompressFormat.PNG)) {
1693				avatar.type = "image/png";
1694			}
1695			if (!getFileBackend().save(avatar)) {
1696				callback.error(R.string.error_saving_avatar, avatar);
1697				return;
1698			}
1699			final IqPacket packet = this.mIqGenerator.publishAvatar(avatar);
1700			this.sendIqPacket(account, packet, new OnIqPacketReceived() {
1701
1702				@Override
1703				public void onIqPacketReceived(Account account, IqPacket result) {
1704					if (result.getType() == IqPacket.TYPE.RESULT) {
1705						final IqPacket packet = XmppConnectionService.this.mIqGenerator
1706							.publishAvatarMetadata(avatar);
1707						sendIqPacket(account, packet, new OnIqPacketReceived() {
1708
1709							@Override
1710							public void onIqPacketReceived(Account account,
1711									IqPacket result) {
1712								if (result.getType() == IqPacket.TYPE.RESULT) {
1713									if (account.setAvatar(avatar.getFilename())) {
1714										databaseBackend.updateAccount(account);
1715									}
1716									callback.success(avatar);
1717								} else {
1718									callback.error(
1719											R.string.error_publish_avatar_server_reject,
1720											avatar);
1721								}
1722							}
1723						});
1724					} else {
1725						callback.error(
1726								R.string.error_publish_avatar_server_reject,
1727								avatar);
1728					}
1729				}
1730			});
1731		} else {
1732			callback.error(R.string.error_publish_avatar_converting, null);
1733		}
1734	}
1735
1736	public void fetchAvatar(Account account, Avatar avatar) {
1737		fetchAvatar(account, avatar, null);
1738	}
1739
1740	public void fetchAvatar(Account account, final Avatar avatar,
1741			final UiCallback<Avatar> callback) {
1742		IqPacket packet = this.mIqGenerator.retrieveAvatar(avatar);
1743		sendIqPacket(account, packet, new OnIqPacketReceived() {
1744
1745			@Override
1746			public void onIqPacketReceived(Account account, IqPacket result) {
1747				final String ERROR = account.getJid().toBareJid()
1748					+ ": fetching avatar for " + avatar.owner + " failed ";
1749				if (result.getType() == IqPacket.TYPE.RESULT) {
1750					avatar.image = mIqParser.avatarData(result);
1751					if (avatar.image != null) {
1752						if (getFileBackend().save(avatar)) {
1753							if (account.getJid().toBareJid().equals(avatar.owner)) {
1754								if (account.setAvatar(avatar.getFilename())) {
1755									databaseBackend.updateAccount(account);
1756								}
1757								getAvatarService().clear(account);
1758								updateConversationUi();
1759								updateAccountUi();
1760							} else {
1761								Contact contact = account.getRoster()
1762									.getContact(avatar.owner);
1763								contact.setAvatar(avatar.getFilename());
1764								getAvatarService().clear(contact);
1765								updateConversationUi();
1766								updateRosterUi();
1767							}
1768							if (callback != null) {
1769								callback.success(avatar);
1770							}
1771							Log.d(Config.LOGTAG, account.getJid().toBareJid()
1772									+ ": succesfully fetched avatar for "
1773									+ avatar.owner);
1774							return;
1775						}
1776					} else {
1777
1778						Log.d(Config.LOGTAG, ERROR + "(parsing error)");
1779					}
1780				} else {
1781					Element error = result.findChild("error");
1782					if (error == null) {
1783						Log.d(Config.LOGTAG, ERROR + "(server error)");
1784					} else {
1785						Log.d(Config.LOGTAG, ERROR + error.toString());
1786					}
1787				}
1788				if (callback != null) {
1789					callback.error(0, null);
1790				}
1791
1792			}
1793		});
1794	}
1795
1796	public void checkForAvatar(Account account,
1797			final UiCallback<Avatar> callback) {
1798		IqPacket packet = this.mIqGenerator.retrieveAvatarMetaData(null);
1799		this.sendIqPacket(account, packet, new OnIqPacketReceived() {
1800
1801			@Override
1802			public void onIqPacketReceived(Account account, IqPacket packet) {
1803				if (packet.getType() == IqPacket.TYPE.RESULT) {
1804					Element pubsub = packet.findChild("pubsub",
1805							"http://jabber.org/protocol/pubsub");
1806					if (pubsub != null) {
1807						Element items = pubsub.findChild("items");
1808						if (items != null) {
1809							Avatar avatar = Avatar.parseMetadata(items);
1810							if (avatar != null) {
1811								avatar.owner = account.getJid().toBareJid();
1812								if (fileBackend.isAvatarCached(avatar)) {
1813									if (account.setAvatar(avatar.getFilename())) {
1814										databaseBackend.updateAccount(account);
1815									}
1816									getAvatarService().clear(account);
1817									callback.success(avatar);
1818								} else {
1819									fetchAvatar(account, avatar, callback);
1820								}
1821								return;
1822							}
1823						}
1824					}
1825				}
1826				callback.error(0, null);
1827			}
1828		});
1829	}
1830
1831	public void deleteContactOnServer(Contact contact) {
1832		contact.resetOption(Contact.Options.PREEMPTIVE_GRANT);
1833		contact.resetOption(Contact.Options.DIRTY_PUSH);
1834		contact.setOption(Contact.Options.DIRTY_DELETE);
1835		Account account = contact.getAccount();
1836		if (account.getStatus() == Account.State.ONLINE) {
1837			IqPacket iq = new IqPacket(IqPacket.TYPE.SET);
1838			Element item = iq.query(Xmlns.ROSTER).addChild("item");
1839			item.setAttribute("jid", contact.getJid().toString());
1840			item.setAttribute("subscription", "remove");
1841			account.getXmppConnection().sendIqPacket(iq, null);
1842		}
1843	}
1844
1845	public void updateConversation(Conversation conversation) {
1846		this.databaseBackend.updateConversation(conversation);
1847	}
1848
1849	public void reconnectAccount(final Account account, final boolean force) {
1850		new Thread(new Runnable() {
1851
1852			@Override
1853			public void run() {
1854				if (account.getXmppConnection() != null) {
1855					disconnect(account, force);
1856				}
1857				if (!account.isOptionSet(Account.OPTION_DISABLED)) {
1858					if (account.getXmppConnection() == null) {
1859						account.setXmppConnection(createConnection(account));
1860					}
1861					Thread thread = new Thread(account.getXmppConnection());
1862					thread.start();
1863					scheduleWakeupCall((int) (Config.CONNECT_TIMEOUT * 1.2),
1864							false);
1865				} else {
1866					account.getRoster().clearPresences();
1867					account.setXmppConnection(null);
1868				}
1869			}
1870		}).start();
1871	}
1872
1873	public void invite(Conversation conversation, Jid contact) {
1874		MessagePacket packet = mMessageGenerator.invite(conversation, contact);
1875		sendMessagePacket(conversation.getAccount(), packet);
1876	}
1877
1878	public void resetSendingToWaiting(Account account) {
1879		for (Conversation conversation : getConversations()) {
1880			if (conversation.getAccount() == account) {
1881				conversation.findUnsentTextMessages(new Conversation.OnMessageFound() {
1882
1883					@Override
1884					public void onMessageFound(Message message) {
1885						markMessage(message, Message.STATUS_WAITING);
1886					}
1887				});
1888			}
1889		}
1890	}
1891
1892	public boolean markMessage(final Account account, final Jid recipient, final String uuid,
1893			final int status) {
1894		if (uuid == null) {
1895			return false;
1896		} else {
1897			for (Conversation conversation : getConversations()) {
1898				if (conversation.getJid().equals(recipient)
1899						&& conversation.getAccount().equals(account)) {
1900					return markMessage(conversation, uuid, status);
1901						}
1902			}
1903			return false;
1904		}
1905	}
1906
1907	public boolean markMessage(Conversation conversation, String uuid,
1908			int status) {
1909		if (uuid == null) {
1910			return false;
1911		} else {
1912			Message message = conversation.findSentMessageWithUuid(uuid);
1913			if (message!=null) {
1914				markMessage(message,status);
1915				return true;
1916			} else {
1917				return false;
1918			}
1919		}
1920	}
1921
1922	public void markMessage(Message message, int status) {
1923		if (status == Message.STATUS_SEND_FAILED
1924				&& (message.getStatus() == Message.STATUS_SEND_RECEIVED || message
1925					.getStatus() == Message.STATUS_SEND_DISPLAYED)) {
1926			return;
1927					}
1928		message.setStatus(status);
1929		databaseBackend.updateMessage(message);
1930		updateConversationUi();
1931	}
1932
1933	public SharedPreferences getPreferences() {
1934		return PreferenceManager
1935			.getDefaultSharedPreferences(getApplicationContext());
1936	}
1937
1938	public boolean forceEncryption() {
1939		return getPreferences().getBoolean("force_encryption", false);
1940	}
1941
1942	public boolean confirmMessages() {
1943		return getPreferences().getBoolean("confirm_messages", true);
1944	}
1945
1946	public boolean saveEncryptedMessages() {
1947		return !getPreferences().getBoolean("dont_save_encrypted", false);
1948	}
1949
1950	public boolean indicateReceived() {
1951		return getPreferences().getBoolean("indicate_received", false);
1952	}
1953
1954	public void updateConversationUi() {
1955		if (mOnConversationUpdate != null) {
1956			mOnConversationUpdate.onConversationUpdate();
1957		}
1958	}
1959
1960	public void updateAccountUi() {
1961		if (mOnAccountUpdate != null) {
1962			mOnAccountUpdate.onAccountUpdate();
1963		}
1964	}
1965
1966	public void updateRosterUi() {
1967		if (mOnRosterUpdate != null) {
1968			mOnRosterUpdate.onRosterUpdate();
1969		}
1970	}
1971
1972	public void updateBlocklistUi(final OnUpdateBlocklist.Status status) {
1973		if (mOnUpdateBlocklist != null) {
1974			mOnUpdateBlocklist.OnUpdateBlocklist(status);
1975		}
1976	}
1977
1978	public void updateMucRosterUi() {
1979		if (mOnMucRosterUpdate != null) {
1980			mOnMucRosterUpdate.onMucRosterUpdate();
1981		}
1982	}
1983
1984	public Account findAccountByJid(final Jid accountJid) {
1985		for (Account account : this.accounts) {
1986			if (account.getJid().toBareJid().equals(accountJid.toBareJid())) {
1987				return account;
1988			}
1989		}
1990		return null;
1991	}
1992
1993	public Conversation findConversationByUuid(String uuid) {
1994		for (Conversation conversation : getConversations()) {
1995			if (conversation.getUuid().equals(uuid)) {
1996				return conversation;
1997			}
1998		}
1999		return null;
2000	}
2001
2002	public void markRead(final Conversation conversation) {
2003		mNotificationService.clear(conversation);
2004		conversation.markRead();
2005	}
2006
2007	public void sendReadMarker(final Conversation conversation) {
2008		final Message markable = conversation.getLatestMarkableMessage();
2009		this.markRead(conversation);
2010		if (confirmMessages() && markable != null && markable.getRemoteMsgId() != null) {
2011			Log.d(Config.LOGTAG, conversation.getAccount().getJid().toBareJid()+ ": sending read marker to " + markable.getCounterpart().toString());
2012			Account account = conversation.getAccount();
2013			final Jid to = markable.getCounterpart();
2014			MessagePacket packet = mMessageGenerator.confirm(account, to, markable.getRemoteMsgId());
2015			this.sendMessagePacket(conversation.getAccount(),packet);
2016		}
2017		updateConversationUi();
2018	}
2019
2020	public SecureRandom getRNG() {
2021		return this.mRandom;
2022	}
2023
2024	public MemorizingTrustManager getMemorizingTrustManager() {
2025		return this.mMemorizingTrustManager;
2026	}
2027
2028	public PowerManager getPowerManager() {
2029		return this.pm;
2030	}
2031
2032	public LruCache<String, Bitmap> getBitmapCache() {
2033		return this.mBitmapCache;
2034	}
2035
2036	public void syncRosterToDisk(final Account account) {
2037		new Thread(new Runnable() {
2038
2039			@Override
2040			public void run() {
2041				databaseBackend.writeRoster(account.getRoster());
2042			}
2043		}).start();
2044
2045	}
2046
2047	public List<String> getKnownHosts() {
2048		final List<String> hosts = new ArrayList<>();
2049		for (final Account account : getAccounts()) {
2050			if (!hosts.contains(account.getServer().toString())) {
2051				hosts.add(account.getServer().toString());
2052			}
2053			for (final Contact contact : account.getRoster().getContacts()) {
2054				if (contact.showInRoster()) {
2055					final String server = contact.getServer().toString();
2056					if (server != null && !hosts.contains(server)) {
2057						hosts.add(server);
2058					}
2059				}
2060			}
2061		}
2062		return hosts;
2063	}
2064
2065	public List<String> getKnownConferenceHosts() {
2066		final ArrayList<String> mucServers = new ArrayList<>();
2067		for (final Account account : accounts) {
2068			if (account.getXmppConnection() != null) {
2069				final String server = account.getXmppConnection().getMucServer();
2070				if (server != null && !mucServers.contains(server)) {
2071					mucServers.add(server);
2072				}
2073			}
2074		}
2075		return mucServers;
2076	}
2077
2078	public void sendMessagePacket(Account account, MessagePacket packet) {
2079		XmppConnection connection = account.getXmppConnection();
2080		if (connection != null) {
2081			connection.sendMessagePacket(packet);
2082		}
2083	}
2084
2085	public void sendPresencePacket(Account account, PresencePacket packet) {
2086		XmppConnection connection = account.getXmppConnection();
2087		if (connection != null) {
2088			connection.sendPresencePacket(packet);
2089		}
2090	}
2091
2092	public void sendIqPacket(final Account account, final IqPacket packet, final OnIqPacketReceived callback) {
2093		final XmppConnection connection = account.getXmppConnection();
2094		if (connection != null) {
2095			connection.sendIqPacket(packet, callback);
2096		}
2097	}
2098
2099	public MessageGenerator getMessageGenerator() {
2100		return this.mMessageGenerator;
2101	}
2102
2103	public PresenceGenerator getPresenceGenerator() {
2104		return this.mPresenceGenerator;
2105	}
2106
2107	public IqGenerator getIqGenerator() {
2108		return this.mIqGenerator;
2109	}
2110
2111	public IqParser getIqParser() { return this.mIqParser; }
2112
2113	public JingleConnectionManager getJingleConnectionManager() {
2114		return this.mJingleConnectionManager;
2115	}
2116
2117	public MessageArchiveService getMessageArchiveService() {
2118		return this.mMessageArchiveService;
2119	}
2120
2121	public List<Contact> findContacts(Jid jid) {
2122		ArrayList<Contact> contacts = new ArrayList<>();
2123		for (Account account : getAccounts()) {
2124			if (!account.isOptionSet(Account.OPTION_DISABLED)) {
2125				Contact contact = account.getRoster().getContactFromRoster(jid);
2126				if (contact != null) {
2127					contacts.add(contact);
2128				}
2129			}
2130		}
2131		return contacts;
2132	}
2133
2134	public NotificationService getNotificationService() {
2135		return this.mNotificationService;
2136	}
2137
2138	public HttpConnectionManager getHttpConnectionManager() {
2139		return this.mHttpConnectionManager;
2140	}
2141
2142	public void resendFailedMessages(final Message message) {
2143		final Collection<Message> messages = new ArrayList<>();
2144		Message current = message;
2145		while (current.getStatus() == Message.STATUS_SEND_FAILED) {
2146			messages.add(current);
2147			if (current.mergeable(current.next())) {
2148				current = current.next();
2149			} else {
2150				break;
2151			}
2152		}
2153		for (final Message msg : messages) {
2154			markMessage(msg, Message.STATUS_WAITING);
2155			this.resendMessage(msg);
2156		}
2157	}
2158
2159	public void clearConversationHistory(final Conversation conversation) {
2160		conversation.clearMessages();
2161		conversation.setHasMessagesLeftOnServer(false); //avoid messages getting loaded through mam
2162		new Thread(new Runnable() {
2163			@Override
2164			public void run() {
2165				databaseBackend.deleteMessagesInConversation(conversation);
2166			}
2167		}).start();
2168	}
2169
2170	public interface OnConversationUpdate {
2171		public void onConversationUpdate();
2172	}
2173
2174	public interface OnAccountUpdate {
2175		public void onAccountUpdate();
2176	}
2177
2178	public interface OnRosterUpdate {
2179		public void onRosterUpdate();
2180	}
2181
2182	public interface OnMucRosterUpdate {
2183		public void onMucRosterUpdate();
2184	}
2185
2186	private interface OnConferenceOptionsPushed {
2187		public void onPushSucceeded();
2188		public void onPushFailed();
2189	}
2190
2191	public class XmppConnectionBinder extends Binder {
2192		public XmppConnectionService getService() {
2193			return XmppConnectionService.this;
2194		}
2195	}
2196
2197	public void sendBlockRequest(final Blockable blockable) {
2198		if (blockable != null && blockable.getBlockedJid() != null) {
2199			final Jid jid = blockable.getBlockedJid();
2200			this.sendIqPacket(blockable.getAccount(), getIqGenerator().generateSetBlockRequest(jid), new OnIqPacketReceived() {
2201
2202				@Override
2203				public void onIqPacketReceived(final Account account, final IqPacket packet) {
2204					if (packet.getType() == IqPacket.TYPE.RESULT) {
2205						account.getBlocklist().add(jid);
2206						updateBlocklistUi(OnUpdateBlocklist.Status.BLOCKED);
2207					}
2208				}
2209			});
2210		}
2211	}
2212
2213	public void sendUnblockRequest(final Blockable blockable) {
2214		if (blockable != null && blockable.getJid() != null) {
2215			final Jid jid = blockable.getBlockedJid();
2216			this.sendIqPacket(blockable.getAccount(), getIqGenerator().generateSetUnblockRequest(jid), new OnIqPacketReceived() {
2217				@Override
2218				public void onIqPacketReceived(final Account account, final IqPacket packet) {
2219					if (packet.getType() == IqPacket.TYPE.RESULT) {
2220						account.getBlocklist().remove(jid);
2221						updateBlocklistUi(OnUpdateBlocklist.Status.UNBLOCKED);
2222					}
2223				}
2224			});
2225		}
2226	}
2227}