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