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 net.java.otr4j.OtrException;
19import net.java.otr4j.session.Session;
20import net.java.otr4j.session.SessionStatus;
21import eu.siacs.conversations.crypto.PgpEngine;
22import eu.siacs.conversations.entities.Account;
23import eu.siacs.conversations.entities.Bookmark;
24import eu.siacs.conversations.entities.Contact;
25import eu.siacs.conversations.entities.Conversation;
26import eu.siacs.conversations.entities.Message;
27import eu.siacs.conversations.entities.MucOptions;
28import eu.siacs.conversations.entities.MucOptions.OnRenameListener;
29import eu.siacs.conversations.entities.Presences;
30import eu.siacs.conversations.generator.MessageGenerator;
31import eu.siacs.conversations.generator.PresenceGenerator;
32import eu.siacs.conversations.parser.IqParser;
33import eu.siacs.conversations.parser.MessageParser;
34import eu.siacs.conversations.parser.PresenceParser;
35import eu.siacs.conversations.persistance.DatabaseBackend;
36import eu.siacs.conversations.persistance.FileBackend;
37import eu.siacs.conversations.ui.UiCallback;
38import eu.siacs.conversations.utils.CryptoHelper;
39import eu.siacs.conversations.utils.ExceptionHelper;
40import eu.siacs.conversations.utils.OnPhoneContactsLoadedListener;
41import eu.siacs.conversations.utils.PRNGFixes;
42import eu.siacs.conversations.utils.PhoneHelper;
43import eu.siacs.conversations.utils.UIHelper;
44import eu.siacs.conversations.xml.Element;
45import eu.siacs.conversations.xmpp.OnBindListener;
46import eu.siacs.conversations.xmpp.OnContactStatusChanged;
47import eu.siacs.conversations.xmpp.OnIqPacketReceived;
48import eu.siacs.conversations.xmpp.OnStatusChanged;
49import eu.siacs.conversations.xmpp.OnTLSExceptionReceived;
50import eu.siacs.conversations.xmpp.XmppConnection;
51import eu.siacs.conversations.xmpp.jingle.JingleConnectionManager;
52import eu.siacs.conversations.xmpp.jingle.OnJinglePacketReceived;
53import eu.siacs.conversations.xmpp.jingle.stanzas.JinglePacket;
54import eu.siacs.conversations.xmpp.stanzas.IqPacket;
55import eu.siacs.conversations.xmpp.stanzas.MessagePacket;
56import eu.siacs.conversations.xmpp.stanzas.PresencePacket;
57import android.annotation.SuppressLint;
58import android.app.AlarmManager;
59import android.app.PendingIntent;
60import android.app.Service;
61import android.content.Context;
62import android.content.Intent;
63import android.content.SharedPreferences;
64import android.database.ContentObserver;
65import android.net.ConnectivityManager;
66import android.net.NetworkInfo;
67import android.net.Uri;
68import android.os.Binder;
69import android.os.Bundle;
70import android.os.IBinder;
71import android.os.PowerManager;
72import android.os.PowerManager.WakeLock;
73import android.os.SystemClock;
74import android.preference.PreferenceManager;
75import android.provider.ContactsContract;
76import android.util.Log;
77
78public class XmppConnectionService extends Service {
79
80 protected static final String LOGTAG = "xmppService";
81 public DatabaseBackend databaseBackend;
82 private FileBackend fileBackend;
83
84 public long startDate;
85
86 private static final int PING_MAX_INTERVAL = 300;
87 private static final int PING_MIN_INTERVAL = 30;
88 private static final int PING_TIMEOUT = 10;
89 private static final int CONNECT_TIMEOUT = 90;
90 public static final long CARBON_GRACE_PERIOD = 60000L;
91
92 private static String ACTION_MERGE_PHONE_CONTACTS = "merge_phone_contacts";
93
94 private MessageParser mMessageParser = new MessageParser(this);
95 private PresenceParser mPresenceParser = new PresenceParser(this);
96 private IqParser mIqParser = new IqParser(this);
97 private MessageGenerator mMessageGenerator = new MessageGenerator();
98 private PresenceGenerator mPresenceGenerator = new PresenceGenerator();
99
100 private List<Account> accounts;
101 private CopyOnWriteArrayList<Conversation> conversations = null;
102 private JingleConnectionManager mJingleConnectionManager = new JingleConnectionManager(
103 this);
104
105 private OnConversationUpdate mOnConversationUpdate = null;
106 private int convChangedListenerCount = 0;
107 private OnAccountUpdate mOnAccountUpdate = null;
108 private OnRosterUpdate mOnRosterUpdate = null;
109 private OnTLSExceptionReceived tlsException = null;
110 public OnContactStatusChanged onContactStatusChanged = new OnContactStatusChanged() {
111
112 @Override
113 public void onContactStatusChanged(Contact contact, boolean online) {
114 Conversation conversation = findActiveConversation(contact);
115 if (conversation != null) {
116 conversation.endOtrIfNeeded();
117 if (online && (contact.getPresences().size() == 1)) {
118 sendUnsendMessages(conversation);
119 }
120 }
121 }
122 };
123
124 public void setOnTLSExceptionReceivedListener(
125 OnTLSExceptionReceived listener) {
126 tlsException = listener;
127 }
128
129 private SecureRandom mRandom;
130
131 private ContentObserver contactObserver = new ContentObserver(null) {
132 @Override
133 public void onChange(boolean selfChange) {
134 super.onChange(selfChange);
135 Intent intent = new Intent(getApplicationContext(),
136 XmppConnectionService.class);
137 intent.setAction(ACTION_MERGE_PHONE_CONTACTS);
138 startService(intent);
139 }
140 };
141
142 private final IBinder mBinder = new XmppConnectionBinder();
143 private OnStatusChanged statusListener = new OnStatusChanged() {
144
145 @Override
146 public void onStatusChanged(Account account) {
147 if (mOnAccountUpdate != null) {
148 mOnAccountUpdate.onAccountUpdate();;
149 }
150 if (account.getStatus() == Account.STATUS_ONLINE) {
151 for(Conversation conversation : account.pendingConferenceLeaves) {
152 leaveMuc(conversation);
153 }
154 for(Conversation conversation : account.pendingConferenceJoins) {
155 joinMuc(conversation);
156 }
157 mJingleConnectionManager.cancelInTransmission();
158 List<Conversation> conversations = getConversations();
159 for (int i = 0; i < conversations.size(); ++i) {
160 if (conversations.get(i).getAccount() == account) {
161 conversations.get(i).startOtrIfNeeded();
162 sendUnsendMessages(conversations.get(i));
163 }
164 }
165 syncDirtyContacts(account);
166 scheduleWakeupCall(PING_MAX_INTERVAL, true);
167 } else if (account.getStatus() == Account.STATUS_OFFLINE) {
168 if (!account.isOptionSet(Account.OPTION_DISABLED)) {
169 int timeToReconnect = mRandom.nextInt(50) + 10;
170 scheduleWakeupCall(timeToReconnect, false);
171 }
172
173 } else if (account.getStatus() == Account.STATUS_REGISTRATION_SUCCESSFULL) {
174 databaseBackend.updateAccount(account);
175 reconnectAccount(account, true);
176 } else if ((account.getStatus() != Account.STATUS_CONNECTING)
177 && (account.getStatus() != Account.STATUS_NO_INTERNET)) {
178 int next = account.getXmppConnection().getTimeToNextAttempt();
179 Log.d(LOGTAG, account.getJid()
180 + ": error connecting account. try again in " + next
181 + "s for the "
182 + (account.getXmppConnection().getAttempt() + 1)
183 + " time");
184 scheduleWakeupCall(next, false);
185 }
186 UIHelper.showErrorNotification(getApplicationContext(),
187 getAccounts());
188 }
189 };
190
191 private OnJinglePacketReceived jingleListener = new OnJinglePacketReceived() {
192
193 @Override
194 public void onJinglePacketReceived(Account account, JinglePacket packet) {
195 mJingleConnectionManager.deliverPacket(account, packet);
196 }
197 };
198
199 private OpenPgpServiceConnection pgpServiceConnection;
200 private PgpEngine mPgpEngine = null;
201 private Intent pingIntent;
202 private PendingIntent pendingPingIntent = null;
203 private WakeLock wakeLock;
204 private PowerManager pm;
205 private OnBindListener mOnBindListener = new OnBindListener() {
206
207 @Override
208 public void onBind(final Account account) {
209 account.getRoster().clearPresences();
210 account.clearPresences(); // self presences
211 account.pendingConferenceJoins.clear();
212 account.pendingConferenceLeaves.clear();
213 fetchRosterFromServer(account);
214 fetchBookmarks(account);
215 sendPresencePacket(account, mPresenceGenerator.sendPresence(account));
216 connectMultiModeConversations(account);
217 updateConversationUi();
218 }
219 };
220
221 public PgpEngine getPgpEngine() {
222 if (pgpServiceConnection.isBound()) {
223 if (this.mPgpEngine == null) {
224 this.mPgpEngine = new PgpEngine(new OpenPgpApi(
225 getApplicationContext(),
226 pgpServiceConnection.getService()), this);
227 }
228 return mPgpEngine;
229 } else {
230 return null;
231 }
232
233 }
234
235 public FileBackend getFileBackend() {
236 return this.fileBackend;
237 }
238
239 public Message attachImageToConversation(final Conversation conversation,
240 final Uri uri, final UiCallback<Message> callback) {
241 final Message message;
242 if (conversation.getNextEncryption() == Message.ENCRYPTION_PGP) {
243 message = new Message(conversation, "",
244 Message.ENCRYPTION_DECRYPTED);
245 } else {
246 message = new Message(conversation, "",
247 conversation.getNextEncryption());
248 }
249 message.setPresence(conversation.getNextPresence());
250 message.setType(Message.TYPE_IMAGE);
251 message.setStatus(Message.STATUS_OFFERED);
252 new Thread(new Runnable() {
253
254 @Override
255 public void run() {
256 try {
257 getFileBackend().copyImageToPrivateStorage(message, uri);
258 if (conversation.getNextEncryption() == Message.ENCRYPTION_PGP) {
259 getPgpEngine().encrypt(message, callback);
260 } else {
261 callback.success(message);
262 }
263 } catch (FileBackend.ImageCopyException e) {
264 callback.error(e.getResId(), message);
265 }
266 }
267 }).start();
268 return message;
269 }
270
271 public Conversation findMuc(Bookmark bookmark) {
272 return findMuc(bookmark.getJid(), bookmark.getAccount());
273 }
274
275 public Conversation findMuc(String jid, Account account) {
276 for (Conversation conversation : this.conversations) {
277 if (conversation.getContactJid().split("/")[0].equals(jid)
278 && (conversation.getAccount() == account)) {
279 return conversation;
280 }
281 }
282 return null;
283 }
284
285 public class XmppConnectionBinder extends Binder {
286 public XmppConnectionService getService() {
287 return XmppConnectionService.this;
288 }
289 }
290
291 @Override
292 public int onStartCommand(Intent intent, int flags, int startId) {
293 if ((intent != null)
294 && (ACTION_MERGE_PHONE_CONTACTS.equals(intent.getAction()))) {
295 mergePhoneContactsWithRoster();
296 return START_STICKY;
297 } else if ((intent != null)
298 && (Intent.ACTION_SHUTDOWN.equals(intent.getAction()))) {
299 logoutAndSave();
300 return START_NOT_STICKY;
301 }
302 this.wakeLock.acquire();
303 ConnectivityManager cm = (ConnectivityManager) getApplicationContext()
304 .getSystemService(Context.CONNECTIVITY_SERVICE);
305 NetworkInfo activeNetwork = cm.getActiveNetworkInfo();
306 boolean isConnected = activeNetwork != null
307 && activeNetwork.isConnected();
308
309 for (Account account : accounts) {
310 if (!account.isOptionSet(Account.OPTION_DISABLED)) {
311 if (!isConnected) {
312 account.setStatus(Account.STATUS_NO_INTERNET);
313 if (statusListener != null) {
314 statusListener.onStatusChanged(account);
315 }
316 } else {
317 if (account.getStatus() == Account.STATUS_NO_INTERNET) {
318 account.setStatus(Account.STATUS_OFFLINE);
319 if (statusListener != null) {
320 statusListener.onStatusChanged(account);
321 }
322 }
323 if (account.getStatus() == Account.STATUS_ONLINE) {
324 long lastReceived = account.getXmppConnection().lastPaketReceived;
325 long lastSent = account.getXmppConnection().lastPingSent;
326 if (lastSent - lastReceived >= PING_TIMEOUT * 1000) {
327 Log.d(LOGTAG, account.getJid() + ": ping timeout");
328 this.reconnectAccount(account, true);
329 } else if (SystemClock.elapsedRealtime() - lastReceived >= PING_MIN_INTERVAL * 1000) {
330 account.getXmppConnection().sendPing();
331 account.getXmppConnection().lastPingSent = SystemClock
332 .elapsedRealtime();
333 this.scheduleWakeupCall(2, false);
334 }
335 } else if (account.getStatus() == Account.STATUS_OFFLINE) {
336 if (account.getXmppConnection() == null) {
337 account.setXmppConnection(this
338 .createConnection(account));
339 }
340 account.getXmppConnection().lastPingSent = SystemClock
341 .elapsedRealtime();
342 new Thread(account.getXmppConnection()).start();
343 } else if ((account.getStatus() == Account.STATUS_CONNECTING)
344 && ((SystemClock.elapsedRealtime() - account
345 .getXmppConnection().lastConnect) / 1000 >= CONNECT_TIMEOUT)) {
346 Log.d(LOGTAG, account.getJid()
347 + ": time out during connect reconnecting");
348 reconnectAccount(account, true);
349 } else {
350 if (account.getXmppConnection().getTimeToNextAttempt() <= 0) {
351 reconnectAccount(account, true);
352 }
353 }
354 // in any case. reschedule wakup call
355 this.scheduleWakeupCall(PING_MAX_INTERVAL, true);
356 }
357 if (mOnAccountUpdate != null) {
358 mOnAccountUpdate.onAccountUpdate();
359 }
360 }
361 }
362 if (wakeLock.isHeld()) {
363 try {
364 wakeLock.release();
365 } catch (RuntimeException re) {
366 }
367 }
368 return START_STICKY;
369 }
370
371 @SuppressLint("TrulyRandom")
372 @Override
373 public void onCreate() {
374 ExceptionHelper.init(getApplicationContext());
375 PRNGFixes.apply();
376 this.mRandom = new SecureRandom();
377 this.databaseBackend = DatabaseBackend
378 .getInstance(getApplicationContext());
379 this.fileBackend = new FileBackend(getApplicationContext());
380 this.accounts = databaseBackend.getAccounts();
381
382 for (Account account : this.accounts) {
383 this.databaseBackend.readRoster(account.getRoster());
384 }
385 this.mergePhoneContactsWithRoster();
386 this.getConversations();
387
388 getContentResolver().registerContentObserver(
389 ContactsContract.Contacts.CONTENT_URI, true, contactObserver);
390 this.pgpServiceConnection = new OpenPgpServiceConnection(
391 getApplicationContext(), "org.sufficientlysecure.keychain");
392 this.pgpServiceConnection.bindToService();
393
394 this.pm = (PowerManager) getSystemService(Context.POWER_SERVICE);
395 this.wakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK,
396 "XmppConnectionService");
397 }
398
399 @Override
400 public void onDestroy() {
401 super.onDestroy();
402 this.logoutAndSave();
403 }
404
405 @Override
406 public void onTaskRemoved(Intent rootIntent) {
407 super.onTaskRemoved(rootIntent);
408 this.logoutAndSave();
409 }
410
411 private void logoutAndSave() {
412 for (Account account : accounts) {
413 databaseBackend.writeRoster(account.getRoster());
414 if (account.getXmppConnection() != null) {
415 disconnect(account, false);
416 }
417 }
418 Context context = getApplicationContext();
419 AlarmManager alarmManager = (AlarmManager) context
420 .getSystemService(Context.ALARM_SERVICE);
421 Intent intent = new Intent(context, EventReceiver.class);
422 alarmManager.cancel(PendingIntent.getBroadcast(context, 0, intent, 0));
423 Log.d(LOGTAG, "good bye");
424 stopSelf();
425 }
426
427 protected void scheduleWakeupCall(int seconds, boolean ping) {
428 long timeToWake = SystemClock.elapsedRealtime() + seconds * 1000;
429 Context context = getApplicationContext();
430 AlarmManager alarmManager = (AlarmManager) context
431 .getSystemService(Context.ALARM_SERVICE);
432
433 if (ping) {
434 if (this.pingIntent == null) {
435 this.pingIntent = new Intent(context, EventReceiver.class);
436 this.pingIntent.setAction("ping");
437 this.pingIntent.putExtra("time", timeToWake);
438 this.pendingPingIntent = PendingIntent.getBroadcast(context, 0,
439 this.pingIntent, 0);
440 alarmManager.set(AlarmManager.ELAPSED_REALTIME_WAKEUP,
441 timeToWake, pendingPingIntent);
442 } else {
443 long scheduledTime = this.pingIntent.getLongExtra("time", 0);
444 if (scheduledTime < SystemClock.elapsedRealtime()
445 || (scheduledTime > timeToWake)) {
446 this.pingIntent.putExtra("time", timeToWake);
447 alarmManager.cancel(this.pendingPingIntent);
448 this.pendingPingIntent = PendingIntent.getBroadcast(
449 context, 0, this.pingIntent, 0);
450 alarmManager.set(AlarmManager.ELAPSED_REALTIME_WAKEUP,
451 timeToWake, pendingPingIntent);
452 }
453 }
454 } else {
455 Intent intent = new Intent(context, EventReceiver.class);
456 intent.setAction("ping_check");
457 PendingIntent alarmIntent = PendingIntent.getBroadcast(context, 0,
458 intent, 0);
459 alarmManager.set(AlarmManager.ELAPSED_REALTIME_WAKEUP, timeToWake,
460 alarmIntent);
461 }
462
463 }
464
465 public XmppConnection createConnection(Account account) {
466 SharedPreferences sharedPref = getPreferences();
467 account.setResource(sharedPref.getString("resource", "mobile")
468 .toLowerCase(Locale.getDefault()));
469 XmppConnection connection = new XmppConnection(account, this);
470 connection.setOnMessagePacketReceivedListener(this.mMessageParser);
471 connection.setOnStatusChangedListener(this.statusListener);
472 connection.setOnPresencePacketReceivedListener(this.mPresenceParser);
473 connection
474 .setOnUnregisteredIqPacketReceivedListener(this.mIqParser);
475 connection.setOnJinglePacketReceivedListener(this.jingleListener);
476 connection
477 .setOnTLSExceptionReceivedListener(new OnTLSExceptionReceived() {
478
479 @Override
480 public void onTLSExceptionReceived(String fingerprint,
481 Account account) {
482 Log.d(LOGTAG, "tls exception arrived in service");
483 if (tlsException != null) {
484 tlsException.onTLSExceptionReceived(fingerprint,
485 account);
486 }
487 }
488 });
489 connection.setOnBindListener(this.mOnBindListener);
490 return connection;
491 }
492
493 synchronized public void sendMessage(Message message) {
494 Account account = message.getConversation().getAccount();
495 Conversation conv = message.getConversation();
496 MessagePacket packet = null;
497 boolean saveInDb = true;
498 boolean send = false;
499 if (account.getStatus() == Account.STATUS_ONLINE) {
500 if (message.getType() == Message.TYPE_IMAGE) {
501 if (message.getPresence() != null) {
502 if (message.getEncryption() == Message.ENCRYPTION_OTR) {
503 if (!conv.hasValidOtrSession()
504 && (message.getPresence() != null)) {
505 conv.startOtrSession(getApplicationContext(),
506 message.getPresence(), true);
507 message.setStatus(Message.STATUS_WAITING);
508 } else if (conv.hasValidOtrSession()
509 && conv.getOtrSession().getSessionStatus() == SessionStatus.ENCRYPTED) {
510 mJingleConnectionManager
511 .createNewConnection(message);
512 } else if (message.getPresence() == null) {
513 message.setStatus(Message.STATUS_WAITING);
514 }
515 } else {
516 mJingleConnectionManager.createNewConnection(message);
517 }
518 } else {
519 message.setStatus(Message.STATUS_WAITING);
520 }
521 } else {
522 if (message.getEncryption() == Message.ENCRYPTION_OTR) {
523 if (!conv.hasValidOtrSession()
524 && (message.getPresence() != null)) {
525 conv.startOtrSession(getApplicationContext(),
526 message.getPresence(), true);
527 message.setStatus(Message.STATUS_WAITING);
528 } else if (conv.hasValidOtrSession()
529 && conv.getOtrSession().getSessionStatus() == SessionStatus.ENCRYPTED) {
530 message.setPresence(conv.getOtrSession().getSessionID()
531 .getUserID());
532 packet = mMessageGenerator.generateOtrChat(message);
533 send = true;
534 message.setStatus(Message.STATUS_SEND);
535
536 } else if (message.getPresence() == null) {
537 message.setStatus(Message.STATUS_WAITING);
538 }
539 } else if (message.getEncryption() == Message.ENCRYPTION_DECRYPTED) {
540 message.getConversation().endOtrIfNeeded();
541 packet = mMessageGenerator.generatePgpChat(message);
542 message.setStatus(Message.STATUS_SEND);
543 send = true;
544 } else {
545 message.getConversation().endOtrIfNeeded();
546 if (message.getConversation().getMode() == Conversation.MODE_SINGLE) {
547 message.setStatus(Message.STATUS_SEND);
548 }
549 packet = mMessageGenerator.generateChat(message);
550 send = true;
551 }
552 }
553 } else {
554 message.setStatus(Message.STATUS_WAITING);
555 if (message.getType() == Message.TYPE_TEXT) {
556 if (message.getEncryption() == Message.ENCRYPTION_DECRYPTED) {
557 String pgpBody = message.getEncryptedBody();
558 String decryptedBody = message.getBody();
559 message.setBody(pgpBody);
560 databaseBackend.createMessage(message);
561 saveInDb = false;
562 message.setBody(decryptedBody);
563 } else if (message.getEncryption() == Message.ENCRYPTION_OTR) {
564 if (conv.hasValidOtrSession()) {
565 message.setPresence(conv.getOtrSession().getSessionID()
566 .getUserID());
567 } else if (!conv.hasValidOtrSession()
568 && message.getPresence() != null) {
569 conv.startOtrSession(getApplicationContext(),
570 message.getPresence(), false);
571 }
572 }
573 }
574
575 }
576 if (saveInDb) {
577 databaseBackend.createMessage(message);
578 }
579 conv.getMessages().add(message);
580 updateConversationUi();
581 if ((send) && (packet != null)) {
582 sendMessagePacket(account, packet);
583 }
584
585 }
586
587 private void sendUnsendMessages(Conversation conversation) {
588 for (int i = 0; i < conversation.getMessages().size(); ++i) {
589 int status = conversation.getMessages().get(i).getStatus();
590 if (status == Message.STATUS_WAITING) {
591 resendMessage(conversation.getMessages().get(i));
592 }
593 }
594 }
595
596 private void resendMessage(Message message) {
597 Account account = message.getConversation().getAccount();
598 MessagePacket packet = null;
599 if (message.getEncryption() == Message.ENCRYPTION_OTR) {
600 Presences presences = message.getConversation().getContact()
601 .getPresences();
602 if (!message.getConversation().hasValidOtrSession()) {
603 if ((message.getPresence() != null)
604 && (presences.has(message.getPresence()))) {
605 message.getConversation().startOtrSession(
606 getApplicationContext(), message.getPresence(),
607 true);
608 } else {
609 if (presences.size() == 1) {
610 String presence = presences.asStringArray()[0];
611 message.getConversation().startOtrSession(
612 getApplicationContext(), presence, true);
613 }
614 }
615 } else {
616 if (message.getConversation().getOtrSession()
617 .getSessionStatus() == SessionStatus.ENCRYPTED) {
618 if (message.getType() == Message.TYPE_TEXT) {
619 packet = mMessageGenerator.generateOtrChat(message,
620 true);
621 } else if (message.getType() == Message.TYPE_IMAGE) {
622 mJingleConnectionManager.createNewConnection(message);
623 }
624 }
625 }
626 } else if (message.getType() == Message.TYPE_TEXT) {
627 if (message.getEncryption() == Message.ENCRYPTION_NONE) {
628 packet = mMessageGenerator.generateChat(message, true);
629 } else if ((message.getEncryption() == Message.ENCRYPTION_DECRYPTED)
630 || (message.getEncryption() == Message.ENCRYPTION_PGP)) {
631 packet = mMessageGenerator.generatePgpChat(message, true);
632 }
633 } else if (message.getType() == Message.TYPE_IMAGE) {
634 Presences presences = message.getConversation().getContact()
635 .getPresences();
636 if ((message.getPresence() != null)
637 && (presences.has(message.getPresence()))) {
638 markMessage(message, Message.STATUS_OFFERED);
639 mJingleConnectionManager.createNewConnection(message);
640 } else {
641 if (presences.size() == 1) {
642 String presence = presences.asStringArray()[0];
643 message.setPresence(presence);
644 markMessage(message, Message.STATUS_OFFERED);
645 mJingleConnectionManager.createNewConnection(message);
646 }
647 }
648 }
649 if (packet != null) {
650 sendMessagePacket(account,packet);
651 markMessage(message, Message.STATUS_SEND);
652 }
653 }
654
655 public void fetchRosterFromServer(Account account) {
656 IqPacket iqPacket = new IqPacket(IqPacket.TYPE_GET);
657 if (!"".equals(account.getRosterVersion())) {
658 Log.d(LOGTAG, account.getJid() + ": fetching roster version "
659 + account.getRosterVersion());
660 } else {
661 Log.d(LOGTAG, account.getJid() + ": fetching roster");
662 }
663 iqPacket.query("jabber:iq:roster").setAttribute("ver",
664 account.getRosterVersion());
665 account.getXmppConnection().sendIqPacket(iqPacket,
666 new OnIqPacketReceived() {
667
668 @Override
669 public void onIqPacketReceived(final Account account,
670 IqPacket packet) {
671 Element query = packet.findChild("query");
672 if (query != null) {
673 account.getRoster().markAllAsNotInRoster();
674 mIqParser.rosterItems(account, query);
675 }
676 }
677 });
678 }
679
680 public void fetchBookmarks(Account account) {
681 IqPacket iqPacket = new IqPacket(IqPacket.TYPE_GET);
682 Element query = iqPacket.query("jabber:iq:private");
683 query.addChild("storage", "storage:bookmarks");
684 OnIqPacketReceived callback = new OnIqPacketReceived() {
685
686 @Override
687 public void onIqPacketReceived(Account account, IqPacket packet) {
688 Element query = packet.query();
689 List<Bookmark> bookmarks = new ArrayList<Bookmark>();
690 Element storage = query.findChild("storage", "storage:bookmarks");
691 if (storage!=null) {
692 for(Element item : storage.getChildren()) {
693 if (item.getName().equals("conference")) {
694 Bookmark bookmark = Bookmark.parse(item,account);
695 bookmarks.add(bookmark);
696 Conversation conversation = findMuc(bookmark);
697 if (conversation!=null) {
698 conversation.setBookmark(bookmark);
699 } else {
700 if (bookmark.autojoin()) {
701 conversation = findOrCreateConversation(account, bookmark.getJid(), true);
702 conversation.setBookmark(bookmark);
703 joinMuc(conversation);
704 }
705 }
706 }
707 }
708 }
709 account.setBookmarks(bookmarks);
710 }
711 };
712 sendIqPacket(account, iqPacket, callback);
713
714 }
715
716 public void pushBookmarks(Account account) {
717 IqPacket iqPacket = new IqPacket(IqPacket.TYPE_SET);
718 Element query = iqPacket.query("jabber:iq:private");
719 Element storage = query.addChild("storage", "storage:bookmarks");
720 for(Bookmark bookmark : account.getBookmarks()) {
721 storage.addChild(bookmark.toElement());
722 }
723 sendIqPacket(account, iqPacket,null);
724 }
725
726 private void mergePhoneContactsWithRoster() {
727 PhoneHelper.loadPhoneContacts(getApplicationContext(),
728 new OnPhoneContactsLoadedListener() {
729 @Override
730 public void onPhoneContactsLoaded(List<Bundle> phoneContacts) {
731 for (Account account : accounts) {
732 account.getRoster().clearSystemAccounts();
733 }
734 for (Bundle phoneContact : phoneContacts) {
735 for (Account account : accounts) {
736 String jid = phoneContact.getString("jid");
737 Contact contact = account.getRoster()
738 .getContact(jid);
739 String systemAccount = phoneContact
740 .getInt("phoneid")
741 + "#"
742 + phoneContact.getString("lookup");
743 contact.setSystemAccount(systemAccount);
744 contact.setPhotoUri(phoneContact
745 .getString("photouri"));
746 contact.setSystemName(phoneContact
747 .getString("displayname"));
748 }
749 }
750 }
751 });
752 }
753
754 public List<Conversation> getConversations() {
755 if (this.conversations == null) {
756 Hashtable<String, Account> accountLookupTable = new Hashtable<String, Account>();
757 for (Account account : this.accounts) {
758 accountLookupTable.put(account.getUuid(), account);
759 }
760 this.conversations = databaseBackend
761 .getConversations(Conversation.STATUS_AVAILABLE);
762 for (Conversation conv : this.conversations) {
763 Account account = accountLookupTable.get(conv.getAccountUuid());
764 conv.setAccount(account);
765 conv.setMessages(databaseBackend.getMessages(conv, 50));
766 }
767 }
768
769 return this.conversations;
770 }
771
772 public void populateWithOrderedConversations(List<Conversation> list) {
773 list.clear();
774 list.addAll(getConversations());
775 Collections.sort(list, new Comparator<Conversation>() {
776 @Override
777 public int compare(Conversation lhs, Conversation rhs) {
778 Message left = lhs.getLatestMessage();
779 Message right = rhs.getLatestMessage();
780 if (left.getTimeSent() > right.getTimeSent()) {
781 return -1;
782 } else if (left.getTimeSent() < right.getTimeSent()) {
783 return 1;
784 } else {
785 return 0;
786 }
787 }
788 });
789 }
790
791 public List<Message> getMoreMessages(Conversation conversation,
792 long timestamp) {
793 List<Message> messages = databaseBackend.getMessages(conversation, 50,
794 timestamp);
795 for (Message message : messages) {
796 message.setConversation(conversation);
797 }
798 return messages;
799 }
800
801 public List<Account> getAccounts() {
802 return this.accounts;
803 }
804
805 public Conversation findActiveConversation(Contact contact) {
806 for (Conversation conversation : this.getConversations()) {
807 if (conversation.getContact() == contact) {
808 return conversation;
809 }
810 }
811 return null;
812 }
813
814 public Conversation findOrCreateConversation(Account account, String jid,
815 boolean muc) {
816 for (Conversation conv : this.getConversations()) {
817 if ((conv.getAccount().equals(account))
818 && (conv.getContactJid().split("/")[0].equals(jid))) {
819 return conv;
820 }
821 }
822 Conversation conversation = databaseBackend.findConversation(account,
823 jid);
824 if (conversation != null) {
825 conversation.setStatus(Conversation.STATUS_AVAILABLE);
826 conversation.setAccount(account);
827 if (muc) {
828 conversation.setMode(Conversation.MODE_MULTI);
829 } else {
830 conversation.setMode(Conversation.MODE_SINGLE);
831 }
832 conversation.setMessages(databaseBackend.getMessages(conversation,
833 50));
834 this.databaseBackend.updateConversation(conversation);
835 } else {
836 String conversationName;
837 Contact contact = account.getRoster().getContact(jid);
838 if (contact != null) {
839 conversationName = contact.getDisplayName();
840 } else {
841 conversationName = jid.split("@")[0];
842 }
843 if (muc) {
844 conversation = new Conversation(conversationName, account, jid,
845 Conversation.MODE_MULTI);
846 } else {
847 conversation = new Conversation(conversationName, account, jid,
848 Conversation.MODE_SINGLE);
849 }
850 this.databaseBackend.createConversation(conversation);
851 }
852 this.conversations.add(conversation);
853 updateConversationUi();
854 return conversation;
855 }
856
857 public void archiveConversation(Conversation conversation) {
858 if (conversation.getMode() == Conversation.MODE_MULTI) {
859 Bookmark bookmark = conversation.getBookmark();
860 if (bookmark!=null && bookmark.autojoin()) {
861 bookmark.setAutojoin(false);
862 pushBookmarks(bookmark.getAccount());
863 }
864 leaveMuc(conversation);
865 } else {
866 conversation.endOtrIfNeeded();
867 }
868 this.databaseBackend.updateConversation(conversation);
869 this.conversations.remove(conversation);
870 updateConversationUi();
871 }
872
873 public void clearConversationHistory(Conversation conversation) {
874 this.databaseBackend.deleteMessagesInConversation(conversation);
875 this.fileBackend.removeFiles(conversation);
876 conversation.getMessages().clear();
877 updateConversationUi();
878 }
879
880 public int getConversationCount() {
881 return this.databaseBackend.getConversationCount();
882 }
883
884 public void createAccount(Account account) {
885 databaseBackend.createAccount(account);
886 this.accounts.add(account);
887 this.reconnectAccount(account, false);
888 updateAccountUi();
889 }
890
891 public void updateAccount(Account account) {
892 this.statusListener.onStatusChanged(account);
893 databaseBackend.updateAccount(account);
894 reconnectAccount(account, false);
895 updateAccountUi();
896 UIHelper.showErrorNotification(getApplicationContext(), getAccounts());
897 }
898
899 public void deleteAccount(Account account) {
900 if (account.getXmppConnection() != null) {
901 this.disconnect(account, true);
902 }
903 databaseBackend.deleteAccount(account);
904 this.accounts.remove(account);
905 updateAccountUi();
906 UIHelper.showErrorNotification(getApplicationContext(), getAccounts());
907 }
908
909 public void setOnConversationListChangedListener(
910 OnConversationUpdate listener) {
911 this.mOnConversationUpdate = listener;
912 this.convChangedListenerCount++;
913 }
914
915 public void removeOnConversationListChangedListener() {
916 this.convChangedListenerCount--;
917 if (this.convChangedListenerCount == 0) {
918 this.mOnConversationUpdate = null;
919 }
920 }
921
922 public void setOnAccountListChangedListener(OnAccountUpdate listener) {
923 this.mOnAccountUpdate = listener;
924 }
925
926 public void removeOnAccountListChangedListener() {
927 this.mOnAccountUpdate = null;
928 }
929
930 public void setOnRosterUpdateListener(OnRosterUpdate listener) {
931 this.mOnRosterUpdate = listener;
932 }
933
934 public void removeOnRosterUpdateListener() {
935 this.mOnRosterUpdate = null;
936 }
937
938 public void connectMultiModeConversations(Account account) {
939 List<Conversation> conversations = getConversations();
940 for (int i = 0; i < conversations.size(); i++) {
941 Conversation conversation = conversations.get(i);
942 if ((conversation.getMode() == Conversation.MODE_MULTI)
943 && (conversation.getAccount() == account)) {
944 joinMuc(conversation);
945 }
946 }
947 }
948
949 public void joinMuc(Conversation conversation) {
950 Account account = conversation.getAccount();
951 account.pendingConferenceJoins.remove(conversation);
952 account.pendingConferenceLeaves.remove(conversation);
953 if (account.getStatus() == Account.STATUS_ONLINE) {
954 Log.d(LOGTAG,"joining conversation "+conversation.getContactJid());
955 String nick = conversation.getMucOptions().getProposedNick();
956 conversation.getMucOptions().setJoinNick(nick);
957 PresencePacket packet = new PresencePacket();
958 packet.setAttribute("to",conversation.getMucOptions().getJoinJid());
959 Element x = new Element("x");
960 x.setAttribute("xmlns", "http://jabber.org/protocol/muc");
961 String sig = account.getPgpSignature();
962 if (sig != null) {
963 packet.addChild("status").setContent("online");
964 packet.addChild("x", "jabber:x:signed").setContent(sig);
965 }
966 if (conversation.getMessages().size() != 0) {
967 final SimpleDateFormat mDateFormat = new SimpleDateFormat(
968 "yyyy-MM-dd'T'HH:mm:ss.SSS'Z'", Locale.US);
969 mDateFormat.setTimeZone(TimeZone.getTimeZone("UTC"));
970 Date date = new Date(
971 conversation.getLatestMessage().getTimeSent() + 1000);
972 x.addChild("history").setAttribute("since",
973 mDateFormat.format(date));
974 }
975 packet.addChild(x);
976 sendPresencePacket(account, packet);
977 } else {
978 account.pendingConferenceJoins.add(conversation);
979 }
980 }
981
982 private OnRenameListener renameListener = null;
983
984 public void setOnRenameListener(OnRenameListener listener) {
985 this.renameListener = listener;
986 }
987
988 public void renameInMuc(final Conversation conversation, final String nick) {
989 final MucOptions options = conversation.getMucOptions();
990 options.setJoinNick(nick);
991 if (options.online()) {
992 Account account = conversation.getAccount();
993 options.setOnRenameListener(new OnRenameListener() {
994
995 @Override
996 public void onRename(boolean success) {
997 if (renameListener != null) {
998 renameListener.onRename(success);
999 }
1000 if (success) {
1001 conversation.setContactJid(conversation.getMucOptions().getJoinJid());
1002 databaseBackend.updateConversation(conversation);
1003 Bookmark bookmark = conversation.getBookmark();
1004 if (bookmark!=null) {
1005 bookmark.setNick(nick);
1006 pushBookmarks(bookmark.getAccount());
1007 }
1008 }
1009 }
1010 });
1011 options.flagAboutToRename();
1012 PresencePacket packet = new PresencePacket();
1013 packet.setAttribute("to",options.getJoinJid());
1014 packet.setAttribute("from", conversation.getAccount().getFullJid());
1015
1016 String sig = account.getPgpSignature();
1017 if (sig != null) {
1018 packet.addChild("status").setContent("online");
1019 packet.addChild("x", "jabber:x:signed").setContent(sig);
1020 }
1021 sendPresencePacket(account,packet);
1022 } else {
1023 conversation.setContactJid(options.getJoinJid());
1024 databaseBackend.updateConversation(conversation);
1025 if (conversation.getAccount().getStatus() == Account.STATUS_ONLINE) {
1026 Bookmark bookmark = conversation.getBookmark();
1027 if (bookmark!=null) {
1028 bookmark.setNick(nick);
1029 pushBookmarks(bookmark.getAccount());
1030 }
1031 joinMuc(conversation);
1032 }
1033 }
1034 }
1035
1036 public void leaveMuc(Conversation conversation) {
1037 Account account = conversation.getAccount();
1038 account.pendingConferenceJoins.remove(conversation);
1039 account.pendingConferenceLeaves.remove(conversation);
1040 if (account.getStatus() == Account.STATUS_ONLINE) {
1041 PresencePacket packet = new PresencePacket();
1042 packet.setAttribute("to", conversation.getMucOptions().getJoinJid());
1043 packet.setAttribute("from", conversation.getAccount().getFullJid());
1044 packet.setAttribute("type", "unavailable");
1045 sendPresencePacket(conversation.getAccount(),packet);
1046 conversation.getMucOptions().setOffline();
1047 conversation.deregisterWithBookmark();
1048 Log.d(LOGTAG,conversation.getAccount().getJid()+" leaving muc "+conversation.getContactJid());
1049 } else {
1050 account.pendingConferenceLeaves.add(conversation);
1051 }
1052 }
1053
1054 public void disconnect(Account account, boolean force) {
1055 if ((account.getStatus() == Account.STATUS_ONLINE)
1056 || (account.getStatus() == Account.STATUS_DISABLED)) {
1057 if (!force) {
1058 List<Conversation> conversations = getConversations();
1059 for (int i = 0; i < conversations.size(); i++) {
1060 Conversation conversation = conversations.get(i);
1061 if (conversation.getAccount() == account) {
1062 if (conversation.getMode() == Conversation.MODE_MULTI) {
1063 leaveMuc(conversation);
1064 } else {
1065 conversation.endOtrIfNeeded();
1066 }
1067 }
1068 }
1069 }
1070 account.getXmppConnection().disconnect(force);
1071 }
1072 }
1073
1074 @Override
1075 public IBinder onBind(Intent intent) {
1076 return mBinder;
1077 }
1078
1079 public void updateMessage(Message message) {
1080 databaseBackend.updateMessage(message);
1081 }
1082
1083 protected void syncDirtyContacts(Account account) {
1084 for (Contact contact : account.getRoster().getContacts()) {
1085 if (contact.getOption(Contact.Options.DIRTY_PUSH)) {
1086 pushContactToServer(contact);
1087 }
1088 if (contact.getOption(Contact.Options.DIRTY_DELETE)) {
1089 Log.d(LOGTAG, "dirty delete");
1090 deleteContactOnServer(contact);
1091 }
1092 }
1093 }
1094
1095 public void createContact(Contact contact) {
1096 SharedPreferences sharedPref = getPreferences();
1097 boolean autoGrant = sharedPref.getBoolean("grant_new_contacts", true);
1098 if (autoGrant) {
1099 contact.setOption(Contact.Options.PREEMPTIVE_GRANT);
1100 contact.setOption(Contact.Options.ASKING);
1101 }
1102 pushContactToServer(contact);
1103 }
1104
1105 public void onOtrSessionEstablished(Conversation conversation) {
1106 Account account = conversation.getAccount();
1107 List<Message> messages = conversation.getMessages();
1108 Session otrSession = conversation.getOtrSession();
1109 Log.d(LOGTAG, account.getJid() + " otr session established with "
1110 + conversation.getContactJid() + "/"
1111 + otrSession.getSessionID().getUserID());
1112 for (int i = 0; i < messages.size(); ++i) {
1113 Message msg = messages.get(i);
1114 if ((msg.getStatus() == Message.STATUS_UNSEND || msg.getStatus() == Message.STATUS_WAITING)
1115 && (msg.getEncryption() == Message.ENCRYPTION_OTR)) {
1116 msg.setPresence(otrSession.getSessionID().getUserID());
1117 if (msg.getType() == Message.TYPE_TEXT) {
1118 MessagePacket outPacket = mMessageGenerator
1119 .generateOtrChat(msg, true);
1120 if (outPacket != null) {
1121 msg.setStatus(Message.STATUS_SEND);
1122 databaseBackend.updateMessage(msg);
1123 sendMessagePacket(account,outPacket);
1124 }
1125 } else if (msg.getType() == Message.TYPE_IMAGE) {
1126 mJingleConnectionManager.createNewConnection(msg);
1127 }
1128 }
1129 }
1130 notifyUi(conversation, false);
1131 }
1132
1133 public boolean renewSymmetricKey(Conversation conversation) {
1134 Account account = conversation.getAccount();
1135 byte[] symmetricKey = new byte[32];
1136 this.mRandom.nextBytes(symmetricKey);
1137 Session otrSession = conversation.getOtrSession();
1138 if (otrSession != null) {
1139 MessagePacket packet = new MessagePacket();
1140 packet.setType(MessagePacket.TYPE_CHAT);
1141 packet.setFrom(account.getFullJid());
1142 packet.addChild("private", "urn:xmpp:carbons:2");
1143 packet.addChild("no-copy", "urn:xmpp:hints");
1144 packet.setTo(otrSession.getSessionID().getAccountID() + "/"
1145 + otrSession.getSessionID().getUserID());
1146 try {
1147 packet.setBody(otrSession
1148 .transformSending(CryptoHelper.FILETRANSFER
1149 + CryptoHelper.bytesToHex(symmetricKey)));
1150 sendMessagePacket(account,packet);
1151 conversation.setSymmetricKey(symmetricKey);
1152 return true;
1153 } catch (OtrException e) {
1154 return false;
1155 }
1156 }
1157 return false;
1158 }
1159
1160 public void pushContactToServer(Contact contact) {
1161 contact.resetOption(Contact.Options.DIRTY_DELETE);
1162 contact.setOption(Contact.Options.DIRTY_PUSH);
1163 Account account = contact.getAccount();
1164 if (account.getStatus() == Account.STATUS_ONLINE) {
1165 boolean ask = contact.getOption(Contact.Options.ASKING);
1166 boolean sendUpdates = contact.getOption(Contact.Options.PENDING_SUBSCRIPTION_REQUEST)
1167 && contact.getOption(Contact.Options.PREEMPTIVE_GRANT);
1168 IqPacket iq = new IqPacket(IqPacket.TYPE_SET);
1169 iq.query("jabber:iq:roster").addChild(contact.asElement());
1170 account.getXmppConnection().sendIqPacket(iq, null);
1171 if (sendUpdates) {
1172 sendPresencePacket(account, mPresenceGenerator.sendPresenceUpdatesTo(contact));
1173 }
1174 if (ask) {
1175 sendPresencePacket(account, mPresenceGenerator.requestPresenceUpdatesFrom(contact));
1176 }
1177 }
1178 }
1179
1180 public void deleteContactOnServer(Contact contact) {
1181 contact.resetOption(Contact.Options.PREEMPTIVE_GRANT);
1182 contact.resetOption(Contact.Options.DIRTY_PUSH);
1183 contact.setOption(Contact.Options.DIRTY_DELETE);
1184 Account account = contact.getAccount();
1185 if (account.getStatus() == Account.STATUS_ONLINE) {
1186 IqPacket iq = new IqPacket(IqPacket.TYPE_SET);
1187 Element item = iq.query("jabber:iq:roster").addChild("item");
1188 item.setAttribute("jid", contact.getJid());
1189 item.setAttribute("subscription", "remove");
1190 account.getXmppConnection().sendIqPacket(iq, null);
1191 }
1192 }
1193
1194 public void updateConversation(Conversation conversation) {
1195 this.databaseBackend.updateConversation(conversation);
1196 }
1197
1198 public void removeOnTLSExceptionReceivedListener() {
1199 this.tlsException = null;
1200 }
1201
1202 public void reconnectAccount(final Account account, final boolean force) {
1203 new Thread(new Runnable() {
1204
1205 @Override
1206 public void run() {
1207 if (account.getXmppConnection() != null) {
1208 disconnect(account, force);
1209 }
1210 if (!account.isOptionSet(Account.OPTION_DISABLED)) {
1211 if (account.getXmppConnection() == null) {
1212 account.setXmppConnection(createConnection(account));
1213 }
1214 Thread thread = new Thread(account.getXmppConnection());
1215 thread.start();
1216 scheduleWakeupCall((int) (CONNECT_TIMEOUT * 1.2), false);
1217 }
1218 }
1219 }).start();
1220 }
1221
1222 public void inviteToConference(Conversation conversation, String contactJid) {
1223 Account account = conversation.getAccount();
1224 MessagePacket packet = new MessagePacket();
1225 packet.setTo(conversation.getContactJid().split("/")[0]);
1226 packet.setFrom(account.getFullJid());
1227 Element x = new Element("x");
1228 x.setAttribute("xmlns", "http://jabber.org/protocol/muc#user");
1229 Element invite = new Element("invite");
1230 invite.setAttribute("to", contactJid);
1231 x.addChild(invite);
1232 packet.addChild(x);
1233 sendMessagePacket(account,packet);
1234 Log.d(LOGTAG,packet.toString());
1235 }
1236
1237 public boolean markMessage(Account account, String recipient, String uuid,
1238 int status) {
1239 for (Conversation conversation : getConversations()) {
1240 if (conversation.getContactJid().equals(recipient)
1241 && conversation.getAccount().equals(account)) {
1242 return markMessage(conversation, uuid, status);
1243 }
1244 }
1245 return false;
1246 }
1247
1248 public boolean markMessage(Conversation conversation, String uuid,
1249 int status) {
1250 for (Message message : conversation.getMessages()) {
1251 if (message.getUuid().equals(uuid)) {
1252 markMessage(message, status);
1253 return true;
1254 }
1255 }
1256 return false;
1257 }
1258
1259 public void markMessage(Message message, int status) {
1260 message.setStatus(status);
1261 databaseBackend.updateMessage(message);
1262 updateConversationUi();
1263 }
1264
1265 public SharedPreferences getPreferences() {
1266 return PreferenceManager
1267 .getDefaultSharedPreferences(getApplicationContext());
1268 }
1269
1270 public boolean confirmMessages() {
1271 return getPreferences().getBoolean("confirm_messages", true);
1272 }
1273
1274 public void notifyUi(Conversation conversation, boolean notify) {
1275 if (mOnConversationUpdate != null) {
1276 mOnConversationUpdate.onConversationUpdate();
1277 } else {
1278 UIHelper.updateNotification(getApplicationContext(),
1279 getConversations(), conversation, notify);
1280 }
1281 }
1282
1283 public void updateConversationUi() {
1284 if (mOnConversationUpdate != null) {
1285 mOnConversationUpdate.onConversationUpdate();
1286 }
1287 }
1288
1289 public void updateAccountUi() {
1290 if (mOnAccountUpdate != null) {
1291 mOnAccountUpdate.onAccountUpdate();
1292 }
1293 }
1294
1295 public void updateRosterUi() {
1296 if (mOnRosterUpdate != null) {
1297 mOnRosterUpdate.onRosterUpdate();
1298 }
1299 }
1300
1301 public Account findAccountByJid(String accountJid) {
1302 for (Account account : this.accounts) {
1303 if (account.getJid().equals(accountJid)) {
1304 return account;
1305 }
1306 }
1307 return null;
1308 }
1309
1310 public Conversation findConversationByUuid(String uuid) {
1311 for (Conversation conversation : getConversations()) {
1312 if (conversation.getUuid().equals(uuid)) {
1313 return conversation;
1314 }
1315 }
1316 return null;
1317 }
1318
1319 public void markRead(Conversation conversation) {
1320 conversation.markRead();
1321 String id = conversation.popLatestMarkableMessageId();
1322 if (confirmMessages() && id != null) {
1323 Account account = conversation.getAccount();
1324 String to = conversation.getContactJid();
1325 this.sendMessagePacket(conversation.getAccount(), mMessageGenerator.confirm(account, to, id));
1326 }
1327 }
1328
1329 public SecureRandom getRNG() {
1330 return this.mRandom;
1331 }
1332
1333 public PowerManager getPowerManager() {
1334 return this.pm;
1335 }
1336
1337 public void replyWithNotAcceptable(Account account, MessagePacket packet) {
1338 if (account.getStatus() == Account.STATUS_ONLINE) {
1339 MessagePacket error = this.mMessageGenerator
1340 .generateNotAcceptable(packet);
1341 sendMessagePacket(account,error);
1342 }
1343 }
1344
1345 public void syncRosterToDisk(final Account account) {
1346 new Thread(new Runnable() {
1347
1348 @Override
1349 public void run() {
1350 databaseBackend.writeRoster(account.getRoster());
1351 }
1352 }).start();
1353
1354 }
1355
1356 public List<String> getKnownHosts() {
1357 List<String> hosts = new ArrayList<String>();
1358 for (Account account : getAccounts()) {
1359 if (!hosts.contains(account.getServer())) {
1360 hosts.add(account.getServer());
1361 }
1362 for (Contact contact : account.getRoster().getContacts()) {
1363 if (contact.showInRoster()) {
1364 String server = contact.getServer();
1365 if (server != null && !hosts.contains(server)) {
1366 hosts.add(server);
1367 }
1368 }
1369 }
1370 }
1371 return hosts;
1372 }
1373
1374 public List<String> getKnownConferenceHosts() {
1375 ArrayList<String> mucServers = new ArrayList<String>();
1376 for (Account account : accounts) {
1377 if (account.getXmppConnection() != null) {
1378 String server = account.getXmppConnection().getMucServer();
1379 if (server != null) {
1380 mucServers.add(server);
1381 }
1382 }
1383 }
1384 return mucServers;
1385 }
1386
1387 public void sendMessagePacket(Account account, MessagePacket packet) {
1388 account.getXmppConnection().sendMessagePacket(packet);
1389 }
1390
1391 public void sendPresencePacket(Account account, PresencePacket packet) {
1392 account.getXmppConnection().sendPresencePacket(packet);
1393 }
1394
1395 public void sendIqPacket(Account account, IqPacket packet, OnIqPacketReceived callback) {
1396 account.getXmppConnection().sendIqPacket(packet, callback);
1397 }
1398
1399 public MessageGenerator getMessageGenerator() {
1400 return this.mMessageGenerator;
1401 }
1402
1403 public PresenceGenerator getPresenceGenerator() {
1404 return this.mPresenceGenerator;
1405 }
1406
1407 public JingleConnectionManager getJingleConnectionManager() {
1408 return this.mJingleConnectionManager;
1409 }
1410
1411 public interface OnConversationUpdate {
1412 public void onConversationUpdate();
1413 }
1414
1415 public interface OnAccountUpdate {
1416 public void onAccountUpdate();
1417 }
1418
1419 public interface OnRosterUpdate {
1420 public void onRosterUpdate();
1421 }
1422}