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