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