1package eu.siacs.conversations.services;
2
3import java.io.File;
4import java.text.ParseException;
5import java.text.SimpleDateFormat;
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.Random;
13
14import org.openintents.openpgp.util.OpenPgpApi;
15import org.openintents.openpgp.util.OpenPgpServiceConnection;
16
17import net.java.otr4j.OtrException;
18import net.java.otr4j.session.Session;
19import net.java.otr4j.session.SessionStatus;
20
21import eu.siacs.conversations.crypto.PgpEngine;
22import eu.siacs.conversations.crypto.PgpEngine.OpenPgpException;
23import eu.siacs.conversations.entities.Account;
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.persistance.DatabaseBackend;
31import eu.siacs.conversations.persistance.FileBackend;
32import eu.siacs.conversations.persistance.OnPhoneContactsMerged;
33import eu.siacs.conversations.ui.OnAccountListChangedListener;
34import eu.siacs.conversations.ui.OnConversationListChangedListener;
35import eu.siacs.conversations.ui.OnRosterFetchedListener;
36import eu.siacs.conversations.utils.ExceptionHelper;
37import eu.siacs.conversations.utils.MessageParser;
38import eu.siacs.conversations.utils.OnPhoneContactsLoadedListener;
39import eu.siacs.conversations.utils.PhoneHelper;
40import eu.siacs.conversations.utils.UIHelper;
41import eu.siacs.conversations.xml.Element;
42import eu.siacs.conversations.xmpp.OnBindListener;
43import eu.siacs.conversations.xmpp.OnIqPacketReceived;
44import eu.siacs.conversations.xmpp.OnMessagePacketReceived;
45import eu.siacs.conversations.xmpp.OnPresencePacketReceived;
46import eu.siacs.conversations.xmpp.OnStatusChanged;
47import eu.siacs.conversations.xmpp.OnTLSExceptionReceived;
48import eu.siacs.conversations.xmpp.XmppConnection;
49import eu.siacs.conversations.xmpp.jingle.JingleConnectionManager;
50import eu.siacs.conversations.xmpp.jingle.OnJinglePacketReceived;
51import eu.siacs.conversations.xmpp.jingle.stanzas.JinglePacket;
52import eu.siacs.conversations.xmpp.stanzas.IqPacket;
53import eu.siacs.conversations.xmpp.stanzas.MessagePacket;
54import eu.siacs.conversations.xmpp.stanzas.PresencePacket;
55import android.app.AlarmManager;
56import android.app.PendingIntent;
57import android.app.Service;
58import android.content.Context;
59import android.content.Intent;
60import android.content.SharedPreferences;
61import android.database.ContentObserver;
62import android.database.DatabaseUtils;
63import android.net.ConnectivityManager;
64import android.net.NetworkInfo;
65import android.net.Uri;
66import android.os.Binder;
67import android.os.Bundle;
68import android.os.IBinder;
69import android.os.PowerManager;
70import android.os.PowerManager.WakeLock;
71import android.os.SystemClock;
72import android.preference.PreferenceManager;
73import android.provider.ContactsContract;
74import android.util.Log;
75
76public class XmppConnectionService extends Service {
77
78 protected static final String LOGTAG = "xmppService";
79 public DatabaseBackend databaseBackend;
80 private FileBackend fileBackend;
81
82 public long startDate;
83
84 private static final int PING_MAX_INTERVAL = 300;
85 private static final int PING_MIN_INTERVAL = 10;
86 private static final int PING_TIMEOUT = 5;
87 private static final int CONNECT_TIMEOUT = 60;
88 private static final long CARBON_GRACE_PERIOD = 60000L;
89
90 private List<Account> accounts;
91 private List<Conversation> conversations = null;
92 private JingleConnectionManager mJingleConnectionManager = new JingleConnectionManager(this);
93
94 public OnConversationListChangedListener convChangedListener = null;
95 private int convChangedListenerCount = 0;
96 private OnAccountListChangedListener accountChangedListener = null;
97 private OnTLSExceptionReceived tlsException = null;
98
99 public void setOnTLSExceptionReceivedListener(
100 OnTLSExceptionReceived listener) {
101 tlsException = listener;
102 }
103
104 private Random mRandom = new Random(System.currentTimeMillis());
105
106 private long lastCarbonMessageReceived = -CARBON_GRACE_PERIOD;
107
108 private ContentObserver contactObserver = new ContentObserver(null) {
109 @Override
110 public void onChange(boolean selfChange) {
111 super.onChange(selfChange);
112 Log.d(LOGTAG, "contact list has changed");
113 mergePhoneContactsWithRoster(null);
114 }
115 };
116
117 private XmppConnectionService service = this;
118
119 private final IBinder mBinder = new XmppConnectionBinder();
120 private OnMessagePacketReceived messageListener = new OnMessagePacketReceived() {
121
122 @Override
123 public void onMessagePacketReceived(Account account,
124 MessagePacket packet) {
125 Message message = null;
126 boolean notify = true;
127 if(PreferenceManager
128 .getDefaultSharedPreferences(getApplicationContext())
129 .getBoolean("notification_grace_period_after_carbon_received", true)){
130 notify=(SystemClock.elapsedRealtime() - lastCarbonMessageReceived) > CARBON_GRACE_PERIOD;
131 }
132
133 if ((packet.getType() == MessagePacket.TYPE_CHAT)) {
134 String pgpBody = MessageParser.getPgpBody(packet);
135 if (pgpBody != null) {
136 message = MessageParser.parsePgpChat(pgpBody, packet,
137 account, service);
138 message.markUnread();
139 } else if (packet.hasChild("body")
140 && (packet.getBody().startsWith("?OTR"))) {
141 message = MessageParser.parseOtrChat(packet, account,
142 service);
143 if (message != null) {
144 message.markUnread();
145 }
146 } else if (packet.hasChild("body")) {
147 message = MessageParser.parsePlainTextChat(packet, account,
148 service);
149 message.markUnread();
150 } else if (packet.hasChild("received")
151 || (packet.hasChild("sent"))) {
152 message = MessageParser.parseCarbonMessage(packet, account,
153 service);
154 if (message != null) {
155 if (message.getStatus() == Message.STATUS_SEND) {
156 lastCarbonMessageReceived = SystemClock.elapsedRealtime();
157 notify = false;
158 message.getConversation().markRead();
159 } else {
160 message.markUnread();
161 }
162 }
163 }
164
165 } else if (packet.getType() == MessagePacket.TYPE_GROUPCHAT) {
166 message = MessageParser
167 .parseGroupchat(packet, account, service);
168 if (message != null) {
169 if (message.getStatus() == Message.STATUS_RECIEVED) {
170 message.markUnread();
171 } else {
172 message.getConversation().markRead();
173 notify = false;
174 }
175 }
176 } else if (packet.getType() == MessagePacket.TYPE_ERROR) {
177 message = MessageParser.parseError(packet, account, service);
178 } else if (packet.getType() == MessagePacket.TYPE_NORMAL) {
179 if (packet.hasChild("x")) {
180 Element x = packet.findChild("x");
181 if (x.hasChild("invite")) {
182 findOrCreateConversation(account, packet.getFrom(),
183 true);
184 if (convChangedListener != null) {
185 convChangedListener.onConversationListChanged();
186 }
187 Log.d(LOGTAG,
188 "invitation received to " + packet.getFrom());
189 }
190
191 } else {
192 // Log.d(LOGTAG, "unparsed message " + packet.toString());
193 }
194 }
195 if ((message == null) || (message.getBody() == null)) {
196 return;
197 }
198 if (packet.hasChild("delay")) {
199 try {
200 String stamp = packet.findChild("delay").getAttribute(
201 "stamp");
202 stamp = stamp.replace("Z", "+0000");
203 Date date = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ssZ")
204 .parse(stamp);
205 message.setTime(date.getTime());
206 } catch (ParseException e) {
207 Log.d(LOGTAG, "error trying to parse date" + e.getMessage());
208 }
209 }
210 Conversation conversation = message.getConversation();
211 conversation.getMessages().add(message);
212 if (packet.getType() != MessagePacket.TYPE_ERROR) {
213 databaseBackend.createMessage(message);
214 }
215 if (convChangedListener != null) {
216 convChangedListener.onConversationListChanged();
217 } else {
218 UIHelper.updateNotification(getApplicationContext(),
219 getConversations(), message.getConversation(), notify);
220 }
221 }
222 };
223 private OnStatusChanged statusListener = new OnStatusChanged() {
224
225 @Override
226 public void onStatusChanged(Account account) {
227 if (accountChangedListener != null) {
228 accountChangedListener.onAccountListChangedListener();
229 }
230 if (account.getStatus() == Account.STATUS_ONLINE) {
231 List<Conversation> conversations = getConversations();
232 for (int i = 0; i < conversations.size(); ++i) {
233 if (conversations.get(i).getAccount() == account) {
234 sendUnsendMessages(conversations.get(i));
235 }
236 }
237 scheduleWakeupCall(PING_MAX_INTERVAL, true);
238 } else if (account.getStatus() == Account.STATUS_OFFLINE) {
239 if (!account.isOptionSet(Account.OPTION_DISABLED)) {
240 int timeToReconnect = mRandom.nextInt(50) + 10;
241 scheduleWakeupCall(timeToReconnect, false);
242 }
243
244 } else if (account.getStatus() == Account.STATUS_REGISTRATION_SUCCESSFULL) {
245 databaseBackend.updateAccount(account);
246 reconnectAccount(account, true);
247 } else {
248 UIHelper.showErrorNotification(getApplicationContext(), getAccounts());
249 }
250 }
251 };
252
253 private OnPresencePacketReceived presenceListener = new OnPresencePacketReceived() {
254
255 @Override
256 public void onPresencePacketReceived(Account account,
257 PresencePacket packet) {
258 if (packet.hasChild("x","http://jabber.org/protocol/muc#user")) {
259 Conversation muc = findMuc(
260 packet.getAttribute("from").split("/")[0], account);
261 if (muc != null) {
262 muc.getMucOptions().processPacket(packet);
263 } else {
264 Log.d(LOGTAG,account.getJid()+": could not find muc for received muc package "+packet.toString());
265 }
266 } else if (packet.hasChild("x","http://jabber.org/protocol/muc")) {
267 Conversation muc = findMuc(packet.getAttribute("from").split("/")[0], account);
268 if (muc != null) {
269 Log.d(LOGTAG,account.getJid()+": reading muc status packet "+packet.toString());
270 int error = muc.getMucOptions().getError();
271 muc.getMucOptions().processPacket(packet);
272 if ((muc.getMucOptions().getError() != error)
273 && (convChangedListener != null)) {
274 Log.d(LOGTAG, "muc error status changed");
275 convChangedListener.onConversationListChanged();
276 }
277 }
278 } else {
279 String[] fromParts = packet.getAttribute("from").split("/");
280 String type = packet.getAttribute("type");
281 if (fromParts[0].equals(account.getJid())) {
282 if (fromParts.length==2) {
283 if (type == null) {
284 account.updatePresence(fromParts[1],Presences.parseShow(packet.findChild("show")));
285 } else if (type.equals("unavailable")) {
286 account.removePresence(fromParts[1]);
287 }
288 }
289
290 } else {
291 Contact contact = findContact(account, fromParts[0]);
292 if (contact == null) {
293 // most likely roster not synced
294 return;
295 }
296 if (type == null) {
297 if (fromParts.length == 2) {
298 contact.updatePresence(fromParts[1], Presences.parseShow(packet.findChild("show")));
299 PgpEngine pgp = getPgpEngine();
300 if (pgp != null) {
301 Element x = packet.findChild("x","jabber:x:signed");
302 if (x != null) {
303 try {
304 Element status = packet.findChild("status");
305 String msg;
306 if (status!=null) {
307 msg = status.getContent();
308 } else {
309 msg = "";
310 }
311 contact.setPgpKeyId(pgp.fetchKeyId(account,msg, x
312 .getContent()));
313 } catch (OpenPgpException e) {
314 Log.d(LOGTAG, "faulty pgp. just ignore");
315 }
316 }
317 }
318 databaseBackend.updateContact(contact);
319 } else {
320 // Log.d(LOGTAG,"presence without resource "+packet.toString());
321 }
322 } else if (type.equals("unavailable")) {
323 if (fromParts.length != 2) {
324 // Log.d(LOGTAG,"received presence with no resource "+packet.toString());
325 } else {
326 contact.removePresence(fromParts[1]);
327 databaseBackend.updateContact(contact);
328 }
329 } else if (type.equals("subscribe")) {
330 if (contact
331 .getSubscriptionOption(Contact.Subscription.PREEMPTIVE_GRANT)) {
332 sendPresenceUpdatesTo(contact);
333 contact.setSubscriptionOption(Contact.Subscription.FROM);
334 contact.resetSubscriptionOption(Contact.Subscription.PREEMPTIVE_GRANT);
335 replaceContactInConversation(contact.getJid(),
336 contact);
337 databaseBackend.updateContact(contact);
338 if ((contact
339 .getSubscriptionOption(Contact.Subscription.ASKING))
340 && (!contact
341 .getSubscriptionOption(Contact.Subscription.TO))) {
342 requestPresenceUpdatesFrom(contact);
343 }
344 } else {
345 // TODO: ask user to handle it maybe
346 }
347 } else {
348 //Log.d(LOGTAG, packet.toString());
349 }
350 replaceContactInConversation(contact.getJid(), contact);
351 }
352 }
353 }
354 };
355
356 private OnIqPacketReceived unknownIqListener = new OnIqPacketReceived() {
357
358 @Override
359 public void onIqPacketReceived(Account account, IqPacket packet) {
360 if (packet.hasChild("query")) {
361 Element query = packet.findChild("query");
362 String xmlns = query.getAttribute("xmlns");
363 if ((xmlns != null) && (xmlns.equals("jabber:iq:roster"))) {
364 processRosterItems(account, query);
365 mergePhoneContactsWithRoster(null);
366 }
367 }
368 }
369 };
370
371 private OnJinglePacketReceived jingleListener = new OnJinglePacketReceived() {
372
373 @Override
374 public void onJinglePacketReceived(Account account, JinglePacket packet) {
375 Log.d(LOGTAG,account.getJid()+": jingle packet received"+packet.toString());
376 }
377 };
378
379 private OpenPgpServiceConnection pgpServiceConnection;
380 private PgpEngine mPgpEngine = null;
381 private Intent pingIntent;
382 private PendingIntent pendingPingIntent = null;
383 private WakeLock wakeLock;
384 private PowerManager pm;
385
386 public PgpEngine getPgpEngine() {
387 if (pgpServiceConnection.isBound()) {
388 if (this.mPgpEngine == null) {
389 this.mPgpEngine = new PgpEngine(new OpenPgpApi(
390 getApplicationContext(),
391 pgpServiceConnection.getService()));
392 }
393 return mPgpEngine;
394 } else {
395 return null;
396 }
397
398 }
399
400 public FileBackend getFileBackend() {
401 return this.fileBackend;
402 }
403
404 public Message attachImageToConversation(Conversation conversation, Uri uri) {
405 Message message = new Message(conversation, "", Message.ENCRYPTION_NONE);
406 message.setType(Message.TYPE_IMAGE);
407 File file = this.fileBackend.copyImageToPrivateStorage(message, uri);
408 Log.d(LOGTAG,"new file"+file.getAbsolutePath());
409 conversation.getMessages().add(message);
410 databaseBackend.createMessage(message);
411 sendMessage(message, null);
412 return message;
413 }
414
415
416 protected Conversation findMuc(String name, Account account) {
417 for (Conversation conversation : this.conversations) {
418 if (conversation.getContactJid().split("/")[0].equals(name)
419 && (conversation.getAccount() == account)) {
420 return conversation;
421 }
422 }
423 return null;
424 }
425
426 private void processRosterItems(Account account, Element elements) {
427 String version = elements.getAttribute("ver");
428 if (version != null) {
429 account.setRosterVersion(version);
430 databaseBackend.updateAccount(account);
431 }
432 for (Element item : elements.getChildren()) {
433 if (item.getName().equals("item")) {
434 String jid = item.getAttribute("jid");
435 String subscription = item.getAttribute("subscription");
436 Contact contact = databaseBackend.findContact(account, jid);
437 if (contact == null) {
438 if (!subscription.equals("remove")) {
439 String name = item.getAttribute("name");
440 if (name == null) {
441 name = jid.split("@")[0];
442 }
443 contact = new Contact(account, name, jid, null);
444 contact.parseSubscriptionFromElement(item);
445 databaseBackend.createContact(contact);
446 }
447 } else {
448 if (subscription.equals("remove")) {
449 databaseBackend.deleteContact(contact);
450 replaceContactInConversation(contact.getJid(), null);
451 } else {
452 contact.parseSubscriptionFromElement(item);
453 databaseBackend.updateContact(contact);
454 replaceContactInConversation(contact.getJid(), contact);
455 }
456 }
457 }
458 }
459 }
460
461 private void replaceContactInConversation(String jid, Contact contact) {
462 List<Conversation> conversations = getConversations();
463 for (int i = 0; i < conversations.size(); ++i) {
464 if ((conversations.get(i).getContactJid().equals(jid))) {
465 conversations.get(i).setContact(contact);
466 break;
467 }
468 }
469 }
470
471 public class XmppConnectionBinder extends Binder {
472 public XmppConnectionService getService() {
473 return XmppConnectionService.this;
474 }
475 }
476
477 @Override
478 public int onStartCommand(Intent intent, int flags, int startId) {
479 this.wakeLock.acquire();
480 // Log.d(LOGTAG,"calling start service. caller was:"+intent.getAction());
481 ConnectivityManager cm = (ConnectivityManager) getApplicationContext()
482 .getSystemService(Context.CONNECTIVITY_SERVICE);
483 NetworkInfo activeNetwork = cm.getActiveNetworkInfo();
484 boolean isConnected = activeNetwork != null
485 && activeNetwork.isConnected();
486
487 for (Account account : accounts) {
488 if (!account.isOptionSet(Account.OPTION_DISABLED)) {
489 if (!isConnected) {
490 account.setStatus(Account.STATUS_NO_INTERNET);
491 if (statusListener != null) {
492 statusListener.onStatusChanged(account);
493 }
494 } else {
495 if (account.getStatus() == Account.STATUS_NO_INTERNET) {
496 account.setStatus(Account.STATUS_OFFLINE);
497 if (statusListener != null) {
498 statusListener.onStatusChanged(account);
499 }
500 }
501
502 // TODO 3 remaining cases
503 if (account.getStatus() == Account.STATUS_ONLINE) {
504 long lastReceived = account.getXmppConnection().lastPaketReceived;
505 long lastSent = account.getXmppConnection().lastPingSent;
506 if (lastSent - lastReceived >= PING_TIMEOUT * 1000) {
507 Log.d(LOGTAG, account.getJid() + ": ping timeout");
508 this.reconnectAccount(account, true);
509 } else if (SystemClock.elapsedRealtime() - lastReceived >= PING_MIN_INTERVAL * 1000) {
510 account.getXmppConnection().sendPing();
511 account.getXmppConnection().lastPingSent = SystemClock
512 .elapsedRealtime();
513 this.scheduleWakeupCall(2, false);
514 }
515 } else if (account.getStatus() == Account.STATUS_OFFLINE) {
516 if (account.getXmppConnection() == null) {
517 account.setXmppConnection(this
518 .createConnection(account));
519 }
520 account.getXmppConnection().lastPingSent = SystemClock
521 .elapsedRealtime();
522 new Thread(account.getXmppConnection()).start();
523 } else if ((account.getStatus() == Account.STATUS_CONNECTING)
524 && ((SystemClock.elapsedRealtime() - account
525 .getXmppConnection().lastConnect) / 1000 >= CONNECT_TIMEOUT)) {
526 Log.d(LOGTAG, account.getJid()
527 + ": time out during connect reconnecting");
528 reconnectAccount(account, true);
529 } else {
530 Log.d(LOGTAG,
531 "seconds since last connect:"
532 + ((SystemClock.elapsedRealtime() - account
533 .getXmppConnection().lastConnect) / 1000));
534 Log.d(LOGTAG,
535 account.getJid() + ": status="
536 + account.getStatus());
537 // TODO notify user of ssl cert problem or auth problem
538 // or what ever
539 }
540 // in any case. reschedule wakup call
541 this.scheduleWakeupCall(PING_MAX_INTERVAL, true);
542 }
543 if (accountChangedListener != null) {
544 accountChangedListener.onAccountListChangedListener();
545 }
546 }
547 }
548 if (wakeLock.isHeld()) {
549 wakeLock.release();
550 }
551 return START_STICKY;
552 }
553
554 @Override
555 public void onCreate() {
556 ExceptionHelper.init(getApplicationContext());
557 this.databaseBackend = DatabaseBackend.getInstance(getApplicationContext());
558 this.fileBackend = new FileBackend(getApplicationContext());
559 this.accounts = databaseBackend.getAccounts();
560
561 this.getConversations();
562
563 getContentResolver().registerContentObserver(
564 ContactsContract.Contacts.CONTENT_URI, true, contactObserver);
565 this.pgpServiceConnection = new OpenPgpServiceConnection(
566 getApplicationContext(), "org.sufficientlysecure.keychain");
567 this.pgpServiceConnection.bindToService();
568
569 this.pm = (PowerManager) getSystemService(Context.POWER_SERVICE);
570 this.wakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK,
571 "XmppConnectionService");
572 }
573
574 @Override
575 public void onDestroy() {
576 super.onDestroy();
577 for (Account account : accounts) {
578 if (account.getXmppConnection() != null) {
579 disconnect(account, true);
580 }
581 }
582 }
583
584 protected void scheduleWakeupCall(int seconds, boolean ping) {
585 long timeToWake = SystemClock.elapsedRealtime() + seconds * 1000;
586 Context context = getApplicationContext();
587 AlarmManager alarmManager = (AlarmManager) context
588 .getSystemService(Context.ALARM_SERVICE);
589
590 if (ping) {
591 if (this.pingIntent == null) {
592 this.pingIntent = new Intent(context, EventReceiver.class);
593 this.pingIntent.setAction("ping");
594 this.pingIntent.putExtra("time", timeToWake);
595 this.pendingPingIntent = PendingIntent.getBroadcast(context, 0,
596 this.pingIntent, 0);
597 alarmManager.set(AlarmManager.ELAPSED_REALTIME_WAKEUP,
598 timeToWake, pendingPingIntent);
599 // Log.d(LOGTAG,"schedule ping in "+seconds+" seconds");
600 } else {
601 long scheduledTime = this.pingIntent.getLongExtra("time", 0);
602 if (scheduledTime < SystemClock.elapsedRealtime()
603 || (scheduledTime > timeToWake)) {
604 this.pingIntent.putExtra("time", timeToWake);
605 alarmManager.cancel(this.pendingPingIntent);
606 this.pendingPingIntent = PendingIntent.getBroadcast(
607 context, 0, this.pingIntent, 0);
608 alarmManager.set(AlarmManager.ELAPSED_REALTIME_WAKEUP,
609 timeToWake, pendingPingIntent);
610 // Log.d(LOGTAG,"reschedule old ping to ping in "+seconds+" seconds");
611 }
612 }
613 } else {
614 Intent intent = new Intent(context, EventReceiver.class);
615 intent.setAction("ping_check");
616 PendingIntent alarmIntent = PendingIntent.getBroadcast(context, 0,
617 intent, 0);
618 alarmManager.set(AlarmManager.ELAPSED_REALTIME_WAKEUP, timeToWake,
619 alarmIntent);
620 }
621
622 }
623
624 public XmppConnection createConnection(Account account) {
625 SharedPreferences sharedPref = PreferenceManager
626 .getDefaultSharedPreferences(getApplicationContext());
627 account.setResource(sharedPref.getString("resource", "mobile").toLowerCase(Locale.getDefault()));
628 XmppConnection connection = new XmppConnection(account, this.pm);
629 connection.setOnMessagePacketReceivedListener(this.messageListener);
630 connection.setOnStatusChangedListener(this.statusListener);
631 connection.setOnPresencePacketReceivedListener(this.presenceListener);
632 connection
633 .setOnUnregisteredIqPacketReceivedListener(this.unknownIqListener);
634 connection.setOnJinglePacketReceivedListener(this.jingleListener);
635 connection
636 .setOnTLSExceptionReceivedListener(new OnTLSExceptionReceived() {
637
638 @Override
639 public void onTLSExceptionReceived(String fingerprint,
640 Account account) {
641 Log.d(LOGTAG, "tls exception arrived in service");
642 if (tlsException != null) {
643 tlsException.onTLSExceptionReceived(fingerprint,
644 account);
645 }
646 }
647 });
648 connection.setOnBindListener(new OnBindListener() {
649
650 @Override
651 public void onBind(Account account) {
652 databaseBackend.clearPresences(account);
653 account.clearPresences(); // self presences
654 if (account.getXmppConnection().hasFeatureRosterManagment()) {
655 updateRoster(account, null);
656 }
657 connectMultiModeConversations(account);
658 if (convChangedListener != null) {
659 convChangedListener.onConversationListChanged();
660 }
661 }
662 });
663 return connection;
664 }
665
666 synchronized public void sendMessage(Message message, String presence) {
667 Account account = message.getConversation().getAccount();
668 Conversation conv = message.getConversation();
669 boolean saveInDb = false;
670 boolean addToConversation = false;
671 if (account.getStatus() == Account.STATUS_ONLINE) {
672 if (message.getType() == Message.TYPE_IMAGE) {
673 mJingleConnectionManager.createNewConnection(message);
674 } else {
675 MessagePacket packet;
676 if (message.getEncryption() == Message.ENCRYPTION_OTR) {
677 if (!conv.hasValidOtrSession()) {
678 // starting otr session. messages will be send later
679 conv.startOtrSession(getApplicationContext(), presence,true);
680 } else if (conv.getOtrSession().getSessionStatus() == SessionStatus.ENCRYPTED) {
681 // otr session aleary exists, creating message packet
682 // accordingly
683 packet = prepareMessagePacket(account, message,
684 conv.getOtrSession());
685 account.getXmppConnection().sendMessagePacket(packet);
686 message.setStatus(Message.STATUS_SEND);
687 }
688 saveInDb = true;
689 addToConversation = true;
690 } else if (message.getEncryption() == Message.ENCRYPTION_PGP) {
691 message.getConversation().endOtrIfNeeded();
692 long keyId = message.getConversation().getContact()
693 .getPgpKeyId();
694 packet = new MessagePacket();
695 packet.setType(MessagePacket.TYPE_CHAT);
696 packet.setFrom(message.getConversation().getAccount()
697 .getFullJid());
698 packet.setTo(message.getCounterpart());
699 packet.setBody("This is an XEP-0027 encryted message");
700 packet.addChild("x", "jabber:x:encrypted").setContent(message.getEncryptedBody());
701 account.getXmppConnection().sendMessagePacket(packet);
702 message.setStatus(Message.STATUS_SEND);
703 message.setEncryption(Message.ENCRYPTION_DECRYPTED);
704 saveInDb = true;
705 addToConversation = true;
706 } else {
707 message.getConversation().endOtrIfNeeded();
708 // don't encrypt
709 if (message.getConversation().getMode() == Conversation.MODE_SINGLE) {
710 message.setStatus(Message.STATUS_SEND);
711 saveInDb = true;
712 addToConversation = true;
713 }
714
715 packet = prepareMessagePacket(account, message, null);
716 account.getXmppConnection().sendMessagePacket(packet);
717 }
718 }
719 } else {
720 // account is offline
721 saveInDb = true;
722 addToConversation = true;
723
724 }
725 if (saveInDb) {
726 databaseBackend.createMessage(message);
727 }
728 if (addToConversation) {
729 conv.getMessages().add(message);
730 if (convChangedListener != null) {
731 convChangedListener.onConversationListChanged();
732 }
733 }
734
735 }
736
737 private void sendUnsendMessages(Conversation conversation) {
738 for (int i = 0; i < conversation.getMessages().size(); ++i) {
739 if ((conversation.getMessages().get(i).getStatus() == Message.STATUS_UNSEND)&&(conversation.getMessages().get(i).getEncryption() == Message.ENCRYPTION_NONE)) {
740 Message message = conversation.getMessages().get(i);
741 MessagePacket packet = prepareMessagePacket(
742 conversation.getAccount(), message, null);
743 conversation.getAccount().getXmppConnection()
744 .sendMessagePacket(packet);
745 message.setStatus(Message.STATUS_SEND);
746 if (conversation.getMode() == Conversation.MODE_SINGLE) {
747 databaseBackend.updateMessage(message);
748 } else {
749 databaseBackend.deleteMessage(message);
750 conversation.getMessages().remove(i);
751 i--;
752 }
753 }
754 }
755 }
756
757 public MessagePacket prepareMessagePacket(Account account, Message message,
758 Session otrSession) {
759 MessagePacket packet = new MessagePacket();
760 if (message.getConversation().getMode() == Conversation.MODE_SINGLE) {
761 packet.setType(MessagePacket.TYPE_CHAT);
762 if (otrSession != null) {
763 try {
764 packet.setBody(otrSession.transformSending(message
765 .getBody()));
766 } catch (OtrException e) {
767 Log.d(LOGTAG,
768 account.getJid()
769 + ": could not encrypt message to "
770 + message.getCounterpart());
771 }
772 packet.addChild("private","urn:xmpp:carbons:2");
773 packet.addChild("no-copy","urn:xmpp:hints");
774 packet.setTo(otrSession.getSessionID().getAccountID() + "/"
775 + otrSession.getSessionID().getUserID());
776 packet.setFrom(account.getFullJid());
777 } else {
778 packet.setBody(message.getBody());
779 packet.setTo(message.getCounterpart());
780 packet.setFrom(account.getJid());
781 }
782 } else if (message.getConversation().getMode() == Conversation.MODE_MULTI) {
783 packet.setType(MessagePacket.TYPE_GROUPCHAT);
784 packet.setBody(message.getBody());
785 packet.setTo(message.getCounterpart().split("/")[0]);
786 packet.setFrom(account.getJid());
787 }
788 return packet;
789 }
790
791 private void getRoster(Account account,
792 final OnRosterFetchedListener listener) {
793 List<Contact> contacts = databaseBackend.getContactsByAccount(account);
794 for (int i = 0; i < contacts.size(); ++i) {
795 contacts.get(i).setAccount(account);
796 }
797 if (listener != null) {
798 listener.onRosterFetched(contacts);
799 }
800 }
801
802 public List<Contact> getRoster(Account account) {
803 List<Contact> contacts = databaseBackend.getContactsByAccount(account);
804 for (int i = 0; i < contacts.size(); ++i) {
805 contacts.get(i).setAccount(account);
806 }
807 return contacts;
808 }
809
810 public void updateRoster(final Account account,
811 final OnRosterFetchedListener listener) {
812 IqPacket iqPacket = new IqPacket(IqPacket.TYPE_GET);
813 if (!"".equals(account.getRosterVersion())) {
814 Log.d(LOGTAG, account.getJid() + ": fetching roster version "
815 + account.getRosterVersion());
816 } else {
817 Log.d(LOGTAG, account.getJid() + ": fetching roster");
818 }
819 iqPacket.query("jabber:iq:roster").setAttribute("ver", account.getRosterVersion());
820 account.getXmppConnection().sendIqPacket(iqPacket,
821 new OnIqPacketReceived() {
822
823 @Override
824 public void onIqPacketReceived(final Account account,
825 IqPacket packet) {
826 Element roster = packet.findChild("query");
827 if (roster != null) {
828 Log.d(LOGTAG, account.getJid()
829 + ": processing roster");
830 processRosterItems(account, roster);
831 StringBuilder mWhere = new StringBuilder();
832 mWhere.append("jid NOT IN(");
833 List<Element> items = roster.getChildren();
834 for (int i = 0; i < items.size(); ++i) {
835 mWhere.append(DatabaseUtils
836 .sqlEscapeString(items.get(i)
837 .getAttribute("jid")));
838 if (i != items.size() - 1) {
839 mWhere.append(",");
840 }
841 }
842 mWhere.append(") and accountUuid = \"");
843 mWhere.append(account.getUuid());
844 mWhere.append("\"");
845 List<Contact> contactsToDelete = databaseBackend
846 .getContacts(mWhere.toString());
847 for (Contact contact : contactsToDelete) {
848 databaseBackend.deleteContact(contact);
849 replaceContactInConversation(contact.getJid(),
850 null);
851 }
852
853 } else {
854 Log.d(LOGTAG, account.getJid()
855 + ": empty roster returend");
856 }
857 mergePhoneContactsWithRoster(new OnPhoneContactsMerged() {
858
859 @Override
860 public void phoneContactsMerged() {
861 if (listener != null) {
862 getRoster(account, listener);
863 }
864 }
865 });
866 }
867 });
868 }
869
870 public void mergePhoneContactsWithRoster(
871 final OnPhoneContactsMerged listener) {
872 PhoneHelper.loadPhoneContacts(getApplicationContext(),
873 new OnPhoneContactsLoadedListener() {
874 @Override
875 public void onPhoneContactsLoaded(
876 Hashtable<String, Bundle> phoneContacts) {
877 List<Contact> contacts = databaseBackend
878 .getContactsByAccount(null);
879 for (int i = 0; i < contacts.size(); ++i) {
880 Contact contact = contacts.get(i);
881 if (phoneContacts.containsKey(contact.getJid())) {
882 Bundle phoneContact = phoneContacts.get(contact
883 .getJid());
884 String systemAccount = phoneContact
885 .getInt("phoneid")
886 + "#"
887 + phoneContact.getString("lookup");
888 contact.setSystemAccount(systemAccount);
889 contact.setPhotoUri(phoneContact
890 .getString("photouri"));
891 contact.setDisplayName(phoneContact
892 .getString("displayname"));
893 databaseBackend.updateContact(contact);
894 replaceContactInConversation(contact.getJid(),
895 contact);
896 } else {
897 if ((contact.getSystemAccount() != null)
898 || (contact.getProfilePhoto() != null)) {
899 contact.setSystemAccount(null);
900 contact.setPhotoUri(null);
901 databaseBackend.updateContact(contact);
902 replaceContactInConversation(
903 contact.getJid(), contact);
904 }
905 }
906 }
907 if (listener != null) {
908 listener.phoneContactsMerged();
909 }
910 }
911 });
912 }
913
914 public List<Conversation> getConversations() {
915 if (this.conversations == null) {
916 Hashtable<String, Account> accountLookupTable = new Hashtable<String, Account>();
917 for (Account account : this.accounts) {
918 accountLookupTable.put(account.getUuid(), account);
919 }
920 this.conversations = databaseBackend
921 .getConversations(Conversation.STATUS_AVAILABLE);
922 for (Conversation conv : this.conversations) {
923 Account account = accountLookupTable.get(conv.getAccountUuid());
924 conv.setAccount(account);
925 conv.setContact(findContact(account, conv.getContactJid()));
926 conv.setMessages(databaseBackend.getMessages(conv, 50));
927 }
928 }
929 Collections.sort(this.conversations, new Comparator<Conversation>() {
930 @Override
931 public int compare(Conversation lhs, Conversation rhs) {
932 return (int) (rhs.getLatestMessage().getTimeSent() - lhs
933 .getLatestMessage().getTimeSent());
934 }
935 });
936 return this.conversations;
937 }
938
939 public List<Account> getAccounts() {
940 return this.accounts;
941 }
942
943 public Contact findContact(Account account, String jid) {
944 Contact contact = databaseBackend.findContact(account, jid);
945 if (contact != null) {
946 contact.setAccount(account);
947 }
948 return contact;
949 }
950
951 public Conversation findOrCreateConversation(Account account, String jid,
952 boolean muc) {
953 for (Conversation conv : this.getConversations()) {
954 if ((conv.getAccount().equals(account))
955 && (conv.getContactJid().split("/")[0].equals(jid))) {
956 return conv;
957 }
958 }
959 Conversation conversation = databaseBackend.findConversation(account,
960 jid);
961 if (conversation != null) {
962 conversation.setStatus(Conversation.STATUS_AVAILABLE);
963 conversation.setAccount(account);
964 if (muc) {
965 conversation.setMode(Conversation.MODE_MULTI);
966 } else {
967 conversation.setMode(Conversation.MODE_SINGLE);
968 }
969 conversation.setMessages(databaseBackend.getMessages(conversation,
970 50));
971 this.databaseBackend.updateConversation(conversation);
972 conversation.setContact(findContact(account,
973 conversation.getContactJid()));
974 } else {
975 String conversationName;
976 Contact contact = findContact(account, jid);
977 if (contact != null) {
978 conversationName = contact.getDisplayName();
979 } else {
980 conversationName = jid.split("@")[0];
981 }
982 if (muc) {
983 conversation = new Conversation(conversationName, account, jid,
984 Conversation.MODE_MULTI);
985 } else {
986 conversation = new Conversation(conversationName, account, jid,
987 Conversation.MODE_SINGLE);
988 }
989 conversation.setContact(contact);
990 this.databaseBackend.createConversation(conversation);
991 }
992 this.conversations.add(conversation);
993 if ((account.getStatus() == Account.STATUS_ONLINE)&&(conversation.getMode() == Conversation.MODE_MULTI)) {
994 joinMuc(conversation);
995 }
996 if (this.convChangedListener != null) {
997 this.convChangedListener.onConversationListChanged();
998 }
999 return conversation;
1000 }
1001
1002 public void archiveConversation(Conversation conversation) {
1003 if (conversation.getMode() == Conversation.MODE_MULTI) {
1004 leaveMuc(conversation);
1005 } else {
1006 conversation.endOtrIfNeeded();
1007 }
1008 this.databaseBackend.updateConversation(conversation);
1009 this.conversations.remove(conversation);
1010 if (this.convChangedListener != null) {
1011 this.convChangedListener.onConversationListChanged();
1012 }
1013 }
1014
1015 public int getConversationCount() {
1016 return this.databaseBackend.getConversationCount();
1017 }
1018
1019 public void createAccount(Account account) {
1020 databaseBackend.createAccount(account);
1021 this.accounts.add(account);
1022 this.reconnectAccount(account, false);
1023 if (accountChangedListener != null)
1024 accountChangedListener.onAccountListChangedListener();
1025 }
1026
1027 public void deleteContact(Contact contact) {
1028 IqPacket iq = new IqPacket(IqPacket.TYPE_SET);
1029 Element query = iq.query("jabber:iq:roster");
1030 query.addChild("item").setAttribute("jid", contact.getJid()).setAttribute("subscription", "remove");
1031 contact.getAccount().getXmppConnection().sendIqPacket(iq, null);
1032 replaceContactInConversation(contact.getJid(), null);
1033 databaseBackend.deleteContact(contact);
1034 }
1035
1036 public void updateAccount(Account account) {
1037 this.statusListener.onStatusChanged(account);
1038 databaseBackend.updateAccount(account);
1039 reconnectAccount(account, false);
1040 if (accountChangedListener != null)
1041 accountChangedListener.onAccountListChangedListener();
1042 }
1043
1044 public void deleteAccount(Account account) {
1045 if (account.getXmppConnection() != null) {
1046 this.disconnect(account, true);
1047 }
1048 databaseBackend.deleteAccount(account);
1049 this.accounts.remove(account);
1050 if (accountChangedListener != null)
1051 accountChangedListener.onAccountListChangedListener();
1052 }
1053
1054 public void setOnConversationListChangedListener(
1055 OnConversationListChangedListener listener) {
1056 this.convChangedListener = listener;
1057 this.convChangedListenerCount++;
1058 Log.d(LOGTAG,"registered on conv changed in backend ("+convChangedListenerCount+")");
1059 }
1060
1061 public void removeOnConversationListChangedListener() {
1062 this.convChangedListenerCount--;
1063 Log.d(LOGTAG,"someone on conv changed listener removed listener ("+convChangedListenerCount+")");
1064 if (this.convChangedListenerCount==0) {
1065 this.convChangedListener = null;
1066 }
1067 }
1068
1069 public void setOnAccountListChangedListener(
1070 OnAccountListChangedListener listener) {
1071 this.accountChangedListener = listener;
1072 }
1073
1074 public void removeOnAccountListChangedListener() {
1075 this.accountChangedListener = null;
1076 }
1077
1078 public void connectMultiModeConversations(Account account) {
1079 List<Conversation> conversations = getConversations();
1080 for (int i = 0; i < conversations.size(); i++) {
1081 Conversation conversation = conversations.get(i);
1082 if ((conversation.getMode() == Conversation.MODE_MULTI)
1083 && (conversation.getAccount() == account)) {
1084 joinMuc(conversation);
1085 }
1086 }
1087 }
1088
1089 public void joinMuc(Conversation conversation) {
1090 String[] mucParts = conversation.getContactJid().split("/");
1091 String muc;
1092 String nick;
1093 if (mucParts.length == 2) {
1094 muc = mucParts[0];
1095 nick = mucParts[1];
1096 } else {
1097 muc = mucParts[0];
1098 nick = conversation.getAccount().getUsername();
1099 }
1100 PresencePacket packet = new PresencePacket();
1101 packet.setAttribute("to", muc + "/" + nick);
1102 Element x = new Element("x");
1103 x.setAttribute("xmlns", "http://jabber.org/protocol/muc");
1104 if (conversation.getMessages().size() != 0) {
1105 long lastMsgTime = conversation.getLatestMessage().getTimeSent();
1106 long diff = (System.currentTimeMillis() - lastMsgTime) / 1000 - 1;
1107 x.addChild("history").setAttribute("seconds", diff + "");
1108 }
1109 packet.addChild(x);
1110 conversation.getAccount().getXmppConnection()
1111 .sendPresencePacket(packet);
1112 }
1113
1114 private OnRenameListener renameListener = null;
1115
1116 public void setOnRenameListener(OnRenameListener listener) {
1117 this.renameListener = listener;
1118 }
1119
1120 public void renameInMuc(final Conversation conversation, final String nick) {
1121 final MucOptions options = conversation.getMucOptions();
1122 if (options.online()) {
1123 options.setOnRenameListener(new OnRenameListener() {
1124
1125 @Override
1126 public void onRename(boolean success) {
1127 if (renameListener != null) {
1128 renameListener.onRename(success);
1129 }
1130 if (success) {
1131 databaseBackend.updateConversation(conversation);
1132 }
1133 }
1134 });
1135 options.flagAboutToRename();
1136 PresencePacket packet = new PresencePacket();
1137 packet.setAttribute("to",
1138 conversation.getContactJid().split("/")[0] + "/" + nick);
1139 packet.setAttribute("from", conversation.getAccount().getFullJid());
1140
1141 conversation.getAccount().getXmppConnection()
1142 .sendPresencePacket(packet, null);
1143 } else {
1144 String jid = conversation.getContactJid().split("/")[0] + "/"
1145 + nick;
1146 conversation.setContactJid(jid);
1147 databaseBackend.updateConversation(conversation);
1148 if (conversation.getAccount().getStatus() == Account.STATUS_ONLINE) {
1149 joinMuc(conversation);
1150 }
1151 }
1152 }
1153
1154 public void leaveMuc(Conversation conversation) {
1155 PresencePacket packet = new PresencePacket();
1156 packet.setAttribute("to", conversation.getContactJid().split("/")[0] + "/" + conversation.getMucOptions().getNick());
1157 packet.setAttribute("from", conversation.getAccount().getFullJid());
1158 packet.setAttribute("type", "unavailable");
1159 Log.d(LOGTAG,"send leaving muc " + packet);
1160 conversation.getAccount().getXmppConnection()
1161 .sendPresencePacket(packet);
1162 conversation.getMucOptions().setOffline();
1163 }
1164
1165 public void disconnect(Account account, boolean force) {
1166 if ((account.getStatus() == Account.STATUS_ONLINE)
1167 || (account.getStatus() == Account.STATUS_DISABLED)) {
1168 if (!force) {
1169 List<Conversation> conversations = getConversations();
1170 for (int i = 0; i < conversations.size(); i++) {
1171 Conversation conversation = conversations.get(i);
1172 if (conversation.getAccount() == account) {
1173 if (conversation.getMode() == Conversation.MODE_MULTI) {
1174 leaveMuc(conversation);
1175 } else {
1176 conversation.endOtrIfNeeded();
1177 }
1178 }
1179 }
1180 }
1181 account.getXmppConnection().disconnect(force);
1182 }
1183 }
1184
1185 @Override
1186 public IBinder onBind(Intent intent) {
1187 return mBinder;
1188 }
1189
1190 public void updateContact(Contact contact) {
1191 databaseBackend.updateContact(contact);
1192 replaceContactInConversation(contact.getJid(), contact);
1193 }
1194
1195 public void updateMessage(Message message) {
1196 databaseBackend.updateMessage(message);
1197 }
1198
1199 public void createContact(Contact contact) {
1200 SharedPreferences sharedPref = PreferenceManager
1201 .getDefaultSharedPreferences(getApplicationContext());
1202 boolean autoGrant = sharedPref.getBoolean("grant_new_contacts", true);
1203 if (autoGrant) {
1204 contact.setSubscriptionOption(Contact.Subscription.PREEMPTIVE_GRANT);
1205 contact.setSubscriptionOption(Contact.Subscription.ASKING);
1206 }
1207 databaseBackend.createContact(contact);
1208 IqPacket iq = new IqPacket(IqPacket.TYPE_SET);
1209 Element query = new Element("query");
1210 query.setAttribute("xmlns", "jabber:iq:roster");
1211 Element item = new Element("item");
1212 item.setAttribute("jid", contact.getJid());
1213 item.setAttribute("name", contact.getJid());
1214 query.addChild(item);
1215 iq.addChild(query);
1216 Account account = contact.getAccount();
1217 account.getXmppConnection().sendIqPacket(iq, null);
1218 if (autoGrant) {
1219 requestPresenceUpdatesFrom(contact);
1220 }
1221 replaceContactInConversation(contact.getJid(), contact);
1222 }
1223
1224 public void requestPresenceUpdatesFrom(Contact contact) {
1225 // Requesting a Subscription type=subscribe
1226 PresencePacket packet = new PresencePacket();
1227 packet.setAttribute("type", "subscribe");
1228 packet.setAttribute("to", contact.getJid());
1229 packet.setAttribute("from", contact.getAccount().getJid());
1230 Log.d(LOGTAG, packet.toString());
1231 contact.getAccount().getXmppConnection().sendPresencePacket(packet);
1232 }
1233
1234 public void stopPresenceUpdatesFrom(Contact contact) {
1235 // Unsubscribing type='unsubscribe'
1236 PresencePacket packet = new PresencePacket();
1237 packet.setAttribute("type", "unsubscribe");
1238 packet.setAttribute("to", contact.getJid());
1239 packet.setAttribute("from", contact.getAccount().getJid());
1240 Log.d(LOGTAG, packet.toString());
1241 contact.getAccount().getXmppConnection().sendPresencePacket(packet);
1242 }
1243
1244 public void stopPresenceUpdatesTo(Contact contact) {
1245 // Canceling a Subscription type=unsubscribed
1246 PresencePacket packet = new PresencePacket();
1247 packet.setAttribute("type", "unsubscribed");
1248 packet.setAttribute("to", contact.getJid());
1249 packet.setAttribute("from", contact.getAccount().getJid());
1250 Log.d(LOGTAG, packet.toString());
1251 contact.getAccount().getXmppConnection().sendPresencePacket(packet);
1252 }
1253
1254 public void sendPresenceUpdatesTo(Contact contact) {
1255 // type='subscribed'
1256 PresencePacket packet = new PresencePacket();
1257 packet.setAttribute("type", "subscribed");
1258 packet.setAttribute("to", contact.getJid());
1259 packet.setAttribute("from", contact.getAccount().getJid());
1260 Log.d(LOGTAG, packet.toString());
1261 contact.getAccount().getXmppConnection().sendPresencePacket(packet);
1262 }
1263
1264 public void sendPgpPresence(Account account, String signature) {
1265 PresencePacket packet = new PresencePacket();
1266 packet.setAttribute("from", account.getFullJid());
1267 Element status = new Element("status");
1268 status.setContent("online");
1269 packet.addChild(status);
1270 Element x = new Element("x");
1271 x.setAttribute("xmlns", "jabber:x:signed");
1272 x.setContent(signature);
1273 packet.addChild(x);
1274 account.getXmppConnection().sendPresencePacket(packet);
1275 }
1276
1277 public void generatePgpAnnouncement(Account account)
1278 throws PgpEngine.UserInputRequiredException {
1279 if (account.getStatus() == Account.STATUS_ONLINE) {
1280 String signature = getPgpEngine().generateSignature("online");
1281 account.setKey("pgp_signature", signature);
1282 databaseBackend.updateAccount(account);
1283 sendPgpPresence(account, signature);
1284 }
1285 }
1286
1287 public void updateConversation(Conversation conversation) {
1288 this.databaseBackend.updateConversation(conversation);
1289 }
1290
1291 public Contact findContact(String uuid) {
1292 Contact contact = this.databaseBackend.getContact(uuid);
1293 if (contact!=null) {
1294 for (Account account : getAccounts()) {
1295 if (contact.getAccountUuid().equals(account.getUuid())) {
1296 contact.setAccount(account);
1297 }
1298 }
1299 }
1300 return contact;
1301 }
1302
1303 public void removeOnTLSExceptionReceivedListener() {
1304 this.tlsException = null;
1305 }
1306
1307 // TODO dont let thread sleep but schedule wake up
1308 public void reconnectAccount(final Account account, final boolean force) {
1309 new Thread(new Runnable() {
1310
1311 @Override
1312 public void run() {
1313 if (account.getXmppConnection() != null) {
1314 disconnect(account, force);
1315 }
1316 if (!account.isOptionSet(Account.OPTION_DISABLED)) {
1317 if (account.getXmppConnection() == null) {
1318 account.setXmppConnection(createConnection(account));
1319 }
1320 Thread thread = new Thread(account.getXmppConnection());
1321 thread.start();
1322 scheduleWakeupCall((int) (CONNECT_TIMEOUT * 1.2), false);
1323 }
1324 }
1325 }).start();
1326 }
1327
1328 public void updateConversationInGui() {
1329 if (convChangedListener != null) {
1330 convChangedListener.onConversationListChanged();
1331 }
1332 }
1333
1334 public void sendConversationSubject(Conversation conversation,
1335 String subject) {
1336 MessagePacket packet = new MessagePacket();
1337 packet.setType(MessagePacket.TYPE_GROUPCHAT);
1338 packet.setTo(conversation.getContactJid().split("/")[0]);
1339 Element subjectChild = new Element("subject");
1340 subjectChild.setContent(subject);
1341 packet.addChild(subjectChild);
1342 packet.setFrom(conversation.getAccount().getJid());
1343 Account account = conversation.getAccount();
1344 if (account.getStatus() == Account.STATUS_ONLINE) {
1345 account.getXmppConnection().sendMessagePacket(packet);
1346 }
1347 }
1348
1349 public void inviteToConference(Conversation conversation,
1350 List<Contact> contacts) {
1351 for (Contact contact : contacts) {
1352 MessagePacket packet = new MessagePacket();
1353 packet.setTo(conversation.getContactJid().split("/")[0]);
1354 packet.setFrom(conversation.getAccount().getFullJid());
1355 Element x = new Element("x");
1356 x.setAttribute("xmlns", "http://jabber.org/protocol/muc#user");
1357 Element invite = new Element("invite");
1358 invite.setAttribute("to", contact.getJid());
1359 x.addChild(invite);
1360 packet.addChild(x);
1361 Log.d(LOGTAG, packet.toString());
1362 conversation.getAccount().getXmppConnection()
1363 .sendMessagePacket(packet);
1364 }
1365
1366 }
1367}