renaming eu.siacs.conversations to de.thedevstack.conversationsplus

 "renaming eu.siacs.conversations to de.thedevstack.conversationsplus"

package renaming completed

4 files changed, 1033 insertions, 0 deletions

diff --git a/src/main/java/de/thedevstack/conversationsplus/parser/AbstractParser.java b/src/main/java/de/thedevstack/conversationsplus/parser/AbstractParser.java
new file mode 100644
index 00000000..5ab0faa6
--- /dev/null
+++ b/src/main/java/de/thedevstack/conversationsplus/parser/AbstractParser.java
@@ -0,0 +1,104 @@
+package de.thedevstack.conversationsplus.parser;
+
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.Locale;
+
+import de.thedevstack.conversationsplus.entities.Account;
+import de.thedevstack.conversationsplus.entities.Contact;
+import de.thedevstack.conversationsplus.services.XmppConnectionService;
+import de.thedevstack.conversationsplus.xml.Element;
+import de.thedevstack.conversationsplus.xmpp.jid.Jid;
+
+public abstract class AbstractParser {
+
+	protected XmppConnectionService mXmppConnectionService;
+
+	protected AbstractParser(XmppConnectionService service) {
+		this.mXmppConnectionService = service;
+	}
+
+    /**
+     * Gets the timestamp from the 'delay' element.
+     * Refer to XEP-0203: Delayed Delivery for details. @link{http://xmpp.org/extensions/xep-0203.html}
+     * @param packet the element to find the child element 'delay' in.
+     * @return the time in milli seconds of the attribute 'stamp' of the
+     *  element 'delay'. In case there is no 'delay' element or no 'stamp'
+     *  attribute or the current time is less than the value of the 'stamp'
+     *  attribute the current time is returned.
+     */
+	protected long getTimestamp(Element packet) {
+		long now = System.currentTimeMillis();
+		Element delay = packet.findChild("delay");
+		if (delay == null) {
+			return now;
+		}
+		String stamp = delay.getAttribute("stamp");
+		if (stamp == null) {
+			return now;
+		}
+        /*long time = parseTimestamp(stamp).getTime();
+        return now < time ? now : time;*/
+        try {
+            long time = parseTimestamp(stamp).getTime();
+            return now < time ? now : time;
+        } catch (ParseException e) {
+            return now;
+        }
+	}
+
+    /**
+     * Parses the timestamp according to XEP-0082: XMPP Date and Time Profiles.
+     * @link{http://xmpp.org/extensions/xep-0082.html}
+     *
+     * @param timestamp the timestamp to parse
+     * @return Date
+     * @throws ParseException
+     */
+	public static Date parseTimestamp(String timestamp) throws ParseException {
+        /*try {
+            Log.d("TIMESTAMP", timestamp);
+            return DatatypeFactory.newInstance().newXMLGregorianCalendar(timestamp).toGregorianCalendar().getTime();
+        } catch (DatatypeConfigurationException e) {
+            Log.d("TIMESTAMP", e.getMessage());
+            return new Date();
+        }*/
+        timestamp = timestamp.replace("Z", "+0000");
+        SimpleDateFormat dateFormat;
+        timestamp = timestamp.substring(0,19)+timestamp.substring(timestamp.length() -5,timestamp.length());
+        dateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ssZ",Locale.US);
+        return dateFormat.parse(timestamp);
+	}
+
+	protected void updateLastseen(final Element packet, final Account account,
+			final boolean presenceOverwrite) {
+		final Jid from = packet.getAttributeAsJid("from");
+        updateLastseen(packet, account, from, presenceOverwrite);
+    }
+
+    protected void updateLastseen(final Element packet, final Account account, final Jid from,
+                                  final boolean presenceOverwrite) {
+		final String presence = from == null || from.isBareJid() ? "" : from.getResourcepart();
+		final Contact contact = account.getRoster().getContact(from);
+		final long timestamp = getTimestamp(packet);
+		if (timestamp >= contact.lastseen.time) {
+			contact.lastseen.time = timestamp;
+			if (!presence.isEmpty() && presenceOverwrite) {
+				contact.lastseen.presence = presence;
+			}
+		}
+	}
+
+	protected String avatarData(Element items) {
+		Element item = items.findChild("item");
+		if (item == null) {
+			return null;
+		}
+		Element data = item.findChild("data", "urn:xmpp:avatar:data");
+		if (data == null) {
+			return null;
+		}
+		return data.getContent();
+	}
+}
diff --git a/src/main/java/de/thedevstack/conversationsplus/parser/IqParser.java b/src/main/java/de/thedevstack/conversationsplus/parser/IqParser.java
new file mode 100644
index 00000000..f76dbf03
--- /dev/null
+++ b/src/main/java/de/thedevstack/conversationsplus/parser/IqParser.java
@@ -0,0 +1,158 @@
+package de.thedevstack.conversationsplus.parser;
+
+import android.util.Log;
+
+import java.util.ArrayList;
+import java.util.Collection;
+
+import de.thedevstack.conversationsplus.Config;
+import de.thedevstack.conversationsplus.entities.Account;
+import de.thedevstack.conversationsplus.entities.Contact;
+import de.thedevstack.conversationsplus.services.XmppConnectionService;
+import de.thedevstack.conversationsplus.utils.Xmlns;
+import de.thedevstack.conversationsplus.xml.Element;
+import de.thedevstack.conversationsplus.xmpp.OnIqPacketReceived;
+import de.thedevstack.conversationsplus.xmpp.OnUpdateBlocklist;
+import de.thedevstack.conversationsplus.xmpp.jid.Jid;
+import de.thedevstack.conversationsplus.xmpp.stanzas.IqPacket;
+
+public class IqParser extends AbstractParser implements OnIqPacketReceived {
+
+	public IqParser(final XmppConnectionService service) {
+		super(service);
+	}
+
+	private void rosterItems(final Account account, final Element query) {
+		final String version = query.getAttribute("ver");
+		if (version != null) {
+			account.getRoster().setVersion(version);
+		}
+		for (final Element item : query.getChildren()) {
+			if (item.getName().equals("item")) {
+				final Jid jid = item.getAttributeAsJid("jid");
+				if (jid == null) {
+					continue;
+				}
+				final String name = item.getAttribute("name");
+				final String subscription = item.getAttribute("subscription");
+				final Contact contact = account.getRoster().getContact(jid);
+				if (!contact.getOption(Contact.Options.DIRTY_PUSH)) {
+					contact.setServerName(name);
+					contact.parseGroupsFromElement(item);
+				}
+				if (subscription != null) {
+					if (subscription.equals("remove")) {
+						contact.resetOption(Contact.Options.IN_ROSTER);
+						contact.resetOption(Contact.Options.DIRTY_DELETE);
+						contact.resetOption(Contact.Options.PREEMPTIVE_GRANT);
+					} else {
+						contact.setOption(Contact.Options.IN_ROSTER);
+						contact.resetOption(Contact.Options.DIRTY_PUSH);
+						contact.parseSubscriptionFromElement(item);
+					}
+				}
+				mXmppConnectionService.getAvatarService().clear(contact);
+			}
+		}
+		mXmppConnectionService.updateConversationUi();
+		mXmppConnectionService.updateRosterUi();
+	}
+
+	public String avatarData(final IqPacket packet) {
+		final Element pubsub = packet.findChild("pubsub",
+				"http://jabber.org/protocol/pubsub");
+		if (pubsub == null) {
+			return null;
+		}
+		final Element items = pubsub.findChild("items");
+		if (items == null) {
+			return null;
+		}
+		return super.avatarData(items);
+	}
+
+	@Override
+	public void onIqPacketReceived(final Account account, final IqPacket packet) {
+		if (packet.hasChild("query", Xmlns.ROSTER) && packet.fromServer(account)) {
+			final Element query = packet.findChild("query");
+			// If this is in response to a query for the whole roster:
+			if (packet.getType() == IqPacket.TYPE.RESULT) {
+				account.getRoster().markAllAsNotInRoster();
+			}
+			this.rosterItems(account, query);
+		} else if ((packet.hasChild("block", Xmlns.BLOCKING) || packet.hasChild("blocklist", Xmlns.BLOCKING)) &&
+				packet.fromServer(account)) {
+			// Block list or block push.
+			Log.d(Config.LOGTAG, "Received blocklist update from server");
+			final Element blocklist = packet.findChild("blocklist", Xmlns.BLOCKING);
+			final Element block = packet.findChild("block", Xmlns.BLOCKING);
+			final Collection<Element> items = blocklist != null ? blocklist.getChildren() :
+				(block != null ? block.getChildren() : null);
+			// If this is a response to a blocklist query, clear the block list and replace with the new one.
+			// Otherwise, just update the existing blocklist.
+			if (packet.getType() == IqPacket.TYPE.RESULT) {
+				account.clearBlocklist();
+				account.getXmppConnection().getFeatures().setBlockListRequested(true);
+			}
+			if (items != null) {
+				final Collection<Jid> jids = new ArrayList<>(items.size());
+				// Create a collection of Jids from the packet
+				for (final Element item : items) {
+					if (item.getName().equals("item")) {
+						final Jid jid = item.getAttributeAsJid("jid");
+						if (jid != null) {
+							jids.add(jid);
+						}
+					}
+				}
+				account.getBlocklist().addAll(jids);
+			}
+			// Update the UI
+			mXmppConnectionService.updateBlocklistUi(OnUpdateBlocklist.Status.BLOCKED);
+		} else if (packet.hasChild("unblock", Xmlns.BLOCKING) &&
+				packet.fromServer(account) && packet.getType() == IqPacket.TYPE.SET) {
+			Log.d(Config.LOGTAG, "Received unblock update from server");
+			final Collection<Element> items = packet.findChild("unblock", Xmlns.BLOCKING).getChildren();
+			if (items.size() == 0) {
+				// No children to unblock == unblock all
+				account.getBlocklist().clear();
+			} else {
+				final Collection<Jid> jids = new ArrayList<>(items.size());
+				for (final Element item : items) {
+					if (item.getName().equals("item")) {
+						final Jid jid = item.getAttributeAsJid("jid");
+						if (jid != null) {
+							jids.add(jid);
+						}
+					}
+				}
+				account.getBlocklist().removeAll(jids);
+			}
+			mXmppConnectionService.updateBlocklistUi(OnUpdateBlocklist.Status.UNBLOCKED);
+		} else if (packet.hasChild("open", "http://jabber.org/protocol/ibb")
+				|| packet.hasChild("data", "http://jabber.org/protocol/ibb")) {
+			mXmppConnectionService.getJingleConnectionManager()
+				.deliverIbbPacket(account, packet);
+		} else if (packet.hasChild("query", "http://jabber.org/protocol/disco#info")) {
+			final IqPacket response = mXmppConnectionService.getIqGenerator().discoResponse(packet);
+			mXmppConnectionService.sendIqPacket(account, response, null);
+		} else if (packet.hasChild("query","jabber:iq:version")) {
+			final IqPacket response = mXmppConnectionService.getIqGenerator().versionResponse(packet);
+			mXmppConnectionService.sendIqPacket(account,response,null);
+		} else if (packet.hasChild("ping", "urn:xmpp:ping")) {
+			final IqPacket response = packet.generateResponse(IqPacket.TYPE.RESULT);
+			mXmppConnectionService.sendIqPacket(account, response, null);
+		} else {
+			if ((packet.getType() == IqPacket.TYPE.GET)
+					|| (packet.getType() == IqPacket.TYPE.SET)) {
+				final IqPacket response = packet.generateResponse(IqPacket.TYPE.ERROR);
+				final Element error = response.addChild("error");
+				error.setAttribute("type", "cancel");
+				error.addChild("feature-not-implemented",
+						"urn:ietf:params:xml:ns:xmpp-stanzas");
+				account.getXmppConnection().sendIqPacket(response, null);
+					}
+		}
+	}
+
+}
diff --git a/src/main/java/de/thedevstack/conversationsplus/parser/MessageParser.java b/src/main/java/de/thedevstack/conversationsplus/parser/MessageParser.java
new file mode 100644
index 00000000..67ff94d2
--- /dev/null
+++ b/src/main/java/de/thedevstack/conversationsplus/parser/MessageParser.java
@@ -0,0 +1,653 @@
+package de.thedevstack.conversationsplus.parser;
+
+import net.java.otr4j.session.Session;
+import net.java.otr4j.session.SessionStatus;
+
+import de.tzur.conversations.Settings;
+import de.thedevstack.conversationsplus.entities.Account;
+import de.thedevstack.conversationsplus.entities.Contact;
+import de.thedevstack.conversationsplus.entities.Conversation;
+import de.thedevstack.conversationsplus.entities.Message;
+import de.thedevstack.conversationsplus.entities.MucOptions;
+import de.thedevstack.conversationsplus.http.HttpConnectionManager;
+import de.thedevstack.conversationsplus.services.MessageArchiveService;
+import de.thedevstack.conversationsplus.services.XmppConnectionService;
+import de.thedevstack.conversationsplus.utils.CryptoHelper;
+import de.thedevstack.conversationsplus.xml.Element;
+import de.thedevstack.conversationsplus.xmpp.OnMessagePacketReceived;
+import de.thedevstack.conversationsplus.xmpp.chatstate.ChatState;
+import de.thedevstack.conversationsplus.xmpp.jid.Jid;
+import de.thedevstack.conversationsplus.xmpp.pep.Avatar;
+import de.thedevstack.conversationsplus.xmpp.stanzas.MessagePacket;
+
+public class MessageParser extends AbstractParser implements
+		OnMessagePacketReceived {
+	public MessageParser(XmppConnectionService service) {
+		super(service);
+	}
+
+	private boolean extractChatState(Conversation conversation, final Element element) {
+		ChatState state = ChatState.parse(element);
+		if (state != null && conversation != null) {
+			final Account account = conversation.getAccount();
+			Jid from = element.getAttributeAsJid("from");
+			if (from != null && from.toBareJid().equals(account.getJid().toBareJid())) {
+				conversation.setOutgoingChatState(state);
+				return false;
+			} else {
+				return conversation.setIncomingChatState(state);
+			}
+		}
+		return false;
+	}
+
+	private Message parseChat(MessagePacket packet, Account account) {
+		final Jid jid = packet.getFrom();
+		if (jid == null) {
+			return null;
+		}
+		Conversation conversation = mXmppConnectionService.findOrCreateConversation(account, jid.toBareJid(), false);
+		String pgpBody = getPgpBody(packet);
+		Message finishedMessage;
+		if (pgpBody != null) {
+			finishedMessage = new Message(conversation,
+					pgpBody, Message.ENCRYPTION_PGP, Message.STATUS_RECEIVED);
+		} else {
+			finishedMessage = new Message(conversation,
+					packet.getBody(), Message.ENCRYPTION_NONE,
+					Message.STATUS_RECEIVED);
+		}
+		finishedMessage.setRemoteMsgId(packet.getId());
+		finishedMessage.markable = isMarkable(packet);
+		if (conversation.getMode() == Conversation.MODE_MULTI
+				&& !jid.isBareJid()) {
+			final Jid trueCounterpart = conversation.getMucOptions()
+					.getTrueCounterpart(jid.getResourcepart());
+			if (trueCounterpart != null) {
+				updateLastseen(packet, account, trueCounterpart, false);
+			}
+			finishedMessage.setType(Message.TYPE_PRIVATE);
+			finishedMessage.setTrueCounterpart(trueCounterpart);
+			if (conversation.hasDuplicateMessage(finishedMessage)) {
+				return null;
+			}
+		} else {
+			updateLastseen(packet, account, true);
+		}
+		finishedMessage.setCounterpart(jid);
+		finishedMessage.setTime(getTimestamp(packet));
+		extractChatState(conversation,packet);
+		return finishedMessage;
+	}
+
+	private Message parseOtrChat(MessagePacket packet, Account account) {
+		final Jid to = packet.getTo();
+		final Jid from = packet.getFrom();
+		if (to == null || from == null) {
+			return null;
+		}
+		boolean properlyAddressed = !to.isBareJid() || account.countPresences() == 1;
+		Conversation conversation = mXmppConnectionService
+				.findOrCreateConversation(account, from.toBareJid(), false);
+		String presence;
+		if (from.isBareJid()) {
+			presence = "";
+		} else {
+			presence = from.getResourcepart();
+		}
+		extractChatState(conversation, packet);
+		updateLastseen(packet, account, true);
+		String body = packet.getBody();
+		if (body.matches("^\\?OTRv\\d{1,2}\\?.*")) {
+			conversation.endOtrIfNeeded();
+		}
+		if (!conversation.hasValidOtrSession()) {
+			if (properlyAddressed) {
+				conversation.startOtrSession(presence,false);
+			} else {
+				return null;
+			}
+		} else {
+			String foreignPresence = conversation.getOtrSession()
+					.getSessionID().getUserID();
+			if (!foreignPresence.equals(presence)) {
+				conversation.endOtrIfNeeded();
+				if (properlyAddressed) {
+					conversation.startOtrSession(presence, false);
+				} else {
+					return null;
+				}
+			}
+		}
+		try {
+			conversation.setLastReceivedOtrMessageId(packet.getId());
+			Session otrSession = conversation.getOtrSession();
+			SessionStatus before = otrSession.getSessionStatus();
+			body = otrSession.transformReceiving(body);
+			SessionStatus after = otrSession.getSessionStatus();
+			if ((before != after) && (after == SessionStatus.ENCRYPTED)) {
+				conversation.setNextEncryption(Message.ENCRYPTION_OTR);
+				mXmppConnectionService.onOtrSessionEstablished(conversation);
+			} else if ((before != after) && (after == SessionStatus.FINISHED)) {
+				conversation.setNextEncryption(Message.ENCRYPTION_NONE);
+				conversation.resetOtrSession();
+				mXmppConnectionService.updateConversationUi();
+			}
+			if ((body == null) || (body.isEmpty())) {
+				return null;
+			}
+			if (body.startsWith(CryptoHelper.FILETRANSFER)) {
+				String key = body.substring(CryptoHelper.FILETRANSFER.length());
+				conversation.setSymmetricKey(CryptoHelper.hexToBytes(key));
+				return null;
+			}
+			Message finishedMessage = new Message(conversation, body, Message.ENCRYPTION_OTR,
+					Message.STATUS_RECEIVED);
+			finishedMessage.setTime(getTimestamp(packet));
+			finishedMessage.setRemoteMsgId(packet.getId());
+			finishedMessage.markable = isMarkable(packet);
+			finishedMessage.setCounterpart(from);
+			conversation.setLastReceivedOtrMessageId(null);
+			return finishedMessage;
+		} catch (Exception e) {
+			conversation.resetOtrSession();
+			return null;
+		}
+	}
+
+	private Message parseGroupchat(MessagePacket packet, Account account) {
+		int status;
+		final Jid from = packet.getFrom();
+		if (from == null) {
+			return null;
+		}
+		if (mXmppConnectionService.find(account.pendingConferenceLeaves,
+				account, from.toBareJid()) != null) {
+			return null;
+		}
+		Conversation conversation = mXmppConnectionService
+				.findOrCreateConversation(account, from.toBareJid(), true);
+		final Jid trueCounterpart = conversation.getMucOptions().getTrueCounterpart(from.getResourcepart());
+		if (trueCounterpart != null) {
+			updateLastseen(packet, account, trueCounterpart, false);
+		}
+		if (packet.hasChild("subject")) {
+			conversation.setHasMessagesLeftOnServer(true);
+			conversation.getMucOptions().setSubject(packet.findChild("subject").getContent());
+			mXmppConnectionService.updateConversationUi();
+			return null;
+		}
+
+		final Element x = packet.findChild("x", "http://jabber.org/protocol/muc#user");
+		if (from.isBareJid() && (x == null || !x.hasChild("status"))) {
+			return null;
+		} else if (from.isBareJid() && x.hasChild("status")) {
+			for(Element child : x.getChildren()) {
+				if (child.getName().equals("status")) {
+					String code = child.getAttribute("code");
+					if (code.contains(MucOptions.STATUS_CODE_ROOM_CONFIG_CHANGED)) {
+						mXmppConnectionService.fetchConferenceConfiguration(conversation);
+					}
+				}
+			}
+			return null;
+		}
+
+		if (from.getResourcepart().equals(conversation.getMucOptions().getActualNick())) {
+			if (mXmppConnectionService.markMessage(conversation,
+					packet.getId(), Message.STATUS_SEND_RECEIVED)) {
+				return null;
+			} else if (packet.getId() == null) {
+				Message message = conversation.findSentMessageWithBody(packet.getBody());
+				if (message != null) {
+					mXmppConnectionService.markMessage(message,Message.STATUS_SEND_RECEIVED);
+					return null;
+				} else {
+					status = Message.STATUS_SEND;
+				}
+			} else {
+				status = Message.STATUS_SEND;
+			}
+		} else {
+			status = Message.STATUS_RECEIVED;
+		}
+		String pgpBody = getPgpBody(packet);
+		Message finishedMessage;
+		if (pgpBody == null) {
+			finishedMessage = new Message(conversation,
+					packet.getBody(), Message.ENCRYPTION_NONE, status);
+		} else {
+			finishedMessage = new Message(conversation, pgpBody,
+					Message.ENCRYPTION_PGP, status);
+		}
+		finishedMessage.setRemoteMsgId(packet.getId());
+		finishedMessage.markable = isMarkable(packet);
+		finishedMessage.setCounterpart(from);
+		if (status == Message.STATUS_RECEIVED) {
+			finishedMessage.setTrueCounterpart(conversation.getMucOptions()
+					.getTrueCounterpart(from.getResourcepart()));
+		}
+		if (packet.hasChild("delay")
+				&& conversation.hasDuplicateMessage(finishedMessage)) {
+			return null;
+		}
+		finishedMessage.setTime(getTimestamp(packet));
+		return finishedMessage;
+	}
+
+	private Message parseCarbonMessage(final MessagePacket packet, final Account account) {
+		int status;
+		final Jid fullJid;
+		Element forwarded;
+		if (packet.hasChild("received", "urn:xmpp:carbons:2")) {
+			forwarded = packet.findChild("received", "urn:xmpp:carbons:2")
+					.findChild("forwarded", "urn:xmpp:forward:0");
+			status = Message.STATUS_RECEIVED;
+		} else if (packet.hasChild("sent", "urn:xmpp:carbons:2")) {
+			forwarded = packet.findChild("sent", "urn:xmpp:carbons:2")
+					.findChild("forwarded", "urn:xmpp:forward:0");
+			status = Message.STATUS_SEND;
+		} else {
+			return null;
+		}
+		if (forwarded == null) {
+			return null;
+		}
+		Element message = forwarded.findChild("message");
+		if (message == null) {
+			return null;
+		}
+		if (!message.hasChild("body")) {
+			if (status == Message.STATUS_RECEIVED
+					&& message.getAttribute("from") != null) {
+				parseNonMessage(message, account);
+			} else if (status == Message.STATUS_SEND
+					&& message.hasChild("displayed", "urn:xmpp:chat-markers:0")) {
+				final Jid to = message.getAttributeAsJid("to");
+				if (to != null) {
+					final Conversation conversation = mXmppConnectionService.find(
+							mXmppConnectionService.getConversations(), account,
+							to.toBareJid());
+					if (conversation != null) {
+						mXmppConnectionService.markRead(conversation);
+					}
+				}
+			}
+			return null;
+		}
+		if (status == Message.STATUS_RECEIVED) {
+			fullJid = message.getAttributeAsJid("from");
+			if (fullJid == null) {
+				return null;
+			} else {
+				updateLastseen(message, account, true);
+			}
+		} else {
+			fullJid = message.getAttributeAsJid("to");
+			if (fullJid == null) {
+				return null;
+			}
+		}
+		if (message.hasChild("x","http://jabber.org/protocol/muc#user")
+				&& "chat".equals(message.getAttribute("type"))) {
+			return null;
+		}
+		Conversation conversation = mXmppConnectionService
+				.findOrCreateConversation(account, fullJid.toBareJid(), false);
+		String pgpBody = getPgpBody(message);
+		Message finishedMessage;
+		if (pgpBody != null) {
+			finishedMessage = new Message(conversation, pgpBody,
+					Message.ENCRYPTION_PGP, status);
+		} else {
+			String body = message.findChild("body").getContent();
+			finishedMessage = new Message(conversation, body,
+					Message.ENCRYPTION_NONE, status);
+		}
+		extractChatState(conversation,message);
+		finishedMessage.setTime(getTimestamp(message));
+		finishedMessage.setRemoteMsgId(message.getAttribute("id"));
+		finishedMessage.markable = isMarkable(message);
+		finishedMessage.setCounterpart(fullJid);
+		if (conversation.getMode() == Conversation.MODE_MULTI
+				&& !fullJid.isBareJid()) {
+			finishedMessage.setType(Message.TYPE_PRIVATE);
+			finishedMessage.setTrueCounterpart(conversation.getMucOptions()
+					.getTrueCounterpart(fullJid.getResourcepart()));
+			if (conversation.hasDuplicateMessage(finishedMessage)) {
+				return null;
+			}
+		}
+		return finishedMessage;
+	}
+
+	private Message parseMamMessage(MessagePacket packet, final Account account) {
+		final Element result = packet.findChild("result","urn:xmpp:mam:0");
+		if (result == null ) {
+			return null;
+		}
+		final MessageArchiveService.Query query = this.mXmppConnectionService.getMessageArchiveService().findQuery(result.getAttribute("queryid"));
+		if (query!=null) {
+			query.incrementTotalCount();
+		}
+		final Element forwarded = result.findChild("forwarded","urn:xmpp:forward:0");
+		if (forwarded == null) {
+			return null;
+		}
+		final Element message = forwarded.findChild("message");
+		if (message == null) {
+			return null;
+		}
+		final Element body = message.findChild("body");
+		if (body == null || message.hasChild("private","urn:xmpp:carbons:2") || message.hasChild("no-copy","urn:xmpp:hints")) {
+			return null;
+		}
+		int encryption;
+		String content = getPgpBody(message);
+		if (content != null) {
+			encryption = Message.ENCRYPTION_PGP;
+		} else {
+			encryption = Message.ENCRYPTION_NONE;
+			content = body.getContent();
+		}
+		if (content == null) {
+			return null;
+		}
+		final long timestamp = getTimestamp(forwarded);
+		final Jid to = message.getAttributeAsJid("to");
+		final Jid from = message.getAttributeAsJid("from");
+		Jid counterpart;
+		int status;
+		Conversation conversation;
+		if (from!=null && to != null && from.toBareJid().equals(account.getJid().toBareJid())) {
+			status = Message.STATUS_SEND;
+			conversation = this.mXmppConnectionService.findOrCreateConversation(account,to.toBareJid(),false,query);
+			counterpart = to;
+		} else if (from !=null && to != null) {
+			status = Message.STATUS_RECEIVED;
+			conversation = this.mXmppConnectionService.findOrCreateConversation(account,from.toBareJid(),false,query);
+			counterpart = from;
+		} else {
+			return null;
+		}
+		Message finishedMessage = new Message(conversation,content,encryption,status);
+		finishedMessage.setTime(timestamp);
+		finishedMessage.setCounterpart(counterpart);
+		finishedMessage.setRemoteMsgId(message.getAttribute("id"));
+		finishedMessage.setServerMsgId(result.getAttribute("id"));
+		if (conversation.hasDuplicateMessage(finishedMessage)) {
+			return null;
+		}
+		if (query!=null) {
+			query.incrementMessageCount();
+		}
+		return finishedMessage;
+	}
+
+	private void parseError(final MessagePacket packet, final Account account) {
+		final Jid from = packet.getFrom();
+		mXmppConnectionService.markMessage(account, from.toBareJid(),
+				packet.getId(), Message.STATUS_SEND_FAILED);
+	}
+
+	private void parseNonMessage(Element packet, Account account) {
+		final Jid from = packet.getAttributeAsJid("from");
+		if (extractChatState(from == null ? null : mXmppConnectionService.find(account,from), packet)) {
+			mXmppConnectionService.updateConversationUi();
+		}
+		Element invite = extractInvite(packet);
+		if (invite != null) {
+			Conversation conversation = mXmppConnectionService.findOrCreateConversation(account, from, true);
+			if (!conversation.getMucOptions().online()) {
+				Element password = invite.findChild("password");
+				conversation.getMucOptions().setPassword(password == null ? null : password.getContent());
+				mXmppConnectionService.databaseBackend.updateConversation(conversation);
+				mXmppConnectionService.joinMuc(conversation);
+				mXmppConnectionService.updateConversationUi();
+			}
+		}
+		if (packet.hasChild("event", "http://jabber.org/protocol/pubsub#event")) {
+			Element event = packet.findChild("event",
+					"http://jabber.org/protocol/pubsub#event");
+			parseEvent(event, from, account);
+		} else if (from != null && packet.hasChild("displayed", "urn:xmpp:chat-markers:0")) {
+			String id = packet
+					.findChild("displayed", "urn:xmpp:chat-markers:0")
+					.getAttribute("id");
+			updateLastseen(packet, account, true);
+			final Message displayedMessage = mXmppConnectionService.markMessage(account, from.toBareJid(), id, Message.STATUS_SEND_DISPLAYED);
+			Message message = displayedMessage == null ? null :displayedMessage.prev();
+			while (message != null
+					&& message.getStatus() == Message.STATUS_SEND_RECEIVED
+					&& message.getTimeSent() < displayedMessage.getTimeSent()) {
+				mXmppConnectionService.markMessage(message, Message.STATUS_SEND_DISPLAYED);
+				message = message.prev();
+			}
+		} else if (from != null
+				&& packet.hasChild("received", "urn:xmpp:chat-markers:0")) {
+			String id = packet.findChild("received", "urn:xmpp:chat-markers:0")
+					.getAttribute("id");
+			updateLastseen(packet, account, false);
+			mXmppConnectionService.markMessage(account, from.toBareJid(),
+					id, Message.STATUS_SEND_RECEIVED);
+		} else if (from != null
+				&& packet.hasChild("received", "urn:xmpp:receipts")) {
+			String id = packet.findChild("received", "urn:xmpp:receipts")
+					.getAttribute("id");
+			updateLastseen(packet, account, false);
+			mXmppConnectionService.markMessage(account, from.toBareJid(),
+					id, Message.STATUS_SEND_RECEIVED);
+		}
+	}
+
+	private Element extractInvite(Element message) {
+		Element x = message.findChild("x","http://jabber.org/protocol/muc#user");
+		if (x == null) {
+			x = message.findChild("x","jabber:x:conference");
+		}
+		if (x != null && x.hasChild("invite")) {
+			return x;
+		} else {
+			return null;
+		}
+	}
+
+	private void parseEvent(final Element event, final Jid from, final Account account) {
+		Element items = event.findChild("items");
+		if (items == null) {
+			return;
+		}
+		String node = items.getAttribute("node");
+		if (node == null) {
+			return;
+		}
+		if (node.equals("urn:xmpp:avatar:metadata")) {
+			Avatar avatar = Avatar.parseMetadata(items);
+			if (avatar != null) {
+				avatar.owner = from;
+				if (mXmppConnectionService.getFileBackend().isAvatarCached(
+						avatar)) {
+					if (account.getJid().toBareJid().equals(from)) {
+						if (account.setAvatar(avatar.getFilename())) {
+							mXmppConnectionService.databaseBackend
+									.updateAccount(account);
+						}
+						mXmppConnectionService.getAvatarService().clear(
+								account);
+						mXmppConnectionService.updateConversationUi();
+						mXmppConnectionService.updateAccountUi();
+					} else {
+						Contact contact = account.getRoster().getContact(
+								from);
+						contact.setAvatar(avatar.getFilename());
+						mXmppConnectionService.getAvatarService().clear(
+								contact);
+						mXmppConnectionService.updateConversationUi();
+						mXmppConnectionService.updateRosterUi();
+					}
+				} else {
+					mXmppConnectionService.fetchAvatar(account, avatar);
+				}
+			}
+		} else if (node.equals("http://jabber.org/protocol/nick")) {
+			Element item = items.findChild("item");
+			if (item != null) {
+				Element nick = item.findChild("nick",
+						"http://jabber.org/protocol/nick");
+				if (nick != null) {
+					if (from != null) {
+						Contact contact = account.getRoster().getContact(
+								from);
+						contact.setPresenceName(nick.getContent());
+						mXmppConnectionService.getAvatarService().clear(account);
+						mXmppConnectionService.updateConversationUi();
+						mXmppConnectionService.updateAccountUi();
+					}
+				}
+			}
+		}
+	}
+
+	private String getPgpBody(Element message) {
+		Element child = message.findChild("x", "jabber:x:encrypted");
+		if (child == null) {
+			return null;
+		} else {
+			return child.getContent();
+		}
+	}
+
+	private boolean isMarkable(Element message) {
+		return message.hasChild("markable", "urn:xmpp:chat-markers:0");
+	}
+
+	@Override
+	public void onMessagePacketReceived(Account account, MessagePacket packet) {
+		Message message = null;
+		this.parseNick(packet, account);
+		if ((packet.getType() == MessagePacket.TYPE_CHAT || packet.getType() == MessagePacket.TYPE_NORMAL)) {
+			if ((packet.getBody() != null)
+					&& (packet.getBody().startsWith("?OTR"))) {
+				message = this.parseOtrChat(packet, account);
+				if (message != null) {
+					message.markUnread();
+				}
+			} else if (packet.hasChild("body") && extractInvite(packet) == null) {
+				message = this.parseChat(packet, account);
+				if (message != null) {
+					message.markUnread();
+				}
+			} else if (packet.hasChild("received", "urn:xmpp:carbons:2")
+					|| (packet.hasChild("sent", "urn:xmpp:carbons:2"))) {
+				message = this.parseCarbonMessage(packet, account);
+				if (message != null) {
+					if (message.getStatus() == Message.STATUS_SEND) {
+						account.activateGracePeriod();
+						mXmppConnectionService.markRead(message.getConversation());
+					} else {
+						message.markUnread();
+					}
+				}
+			} else if (packet.hasChild("result","urn:xmpp:mam:0")) {
+				message = parseMamMessage(packet, account);
+				if (message != null) {
+					Conversation conversation = message.getConversation();
+					conversation.add(message);
+					mXmppConnectionService.databaseBackend.createMessage(message);
+				}
+				return;
+			} else if (packet.hasChild("fin","urn:xmpp:mam:0")) {
+				Element fin = packet.findChild("fin","urn:xmpp:mam:0");
+				mXmppConnectionService.getMessageArchiveService().processFin(fin);
+			} else {
+				parseNonMessage(packet, account);
+			}
+		} else if (packet.getType() == MessagePacket.TYPE_GROUPCHAT) {
+			message = this.parseGroupchat(packet, account);
+			if (message != null) {
+				if (message.getStatus() == Message.STATUS_RECEIVED) {
+					message.markUnread();
+				} else {
+					mXmppConnectionService.markRead(message.getConversation());
+					account.activateGracePeriod();
+				}
+			}
+		} else if (packet.getType() == MessagePacket.TYPE_ERROR) {
+			this.parseError(packet, account);
+			return;
+		} else if (packet.getType() == MessagePacket.TYPE_HEADLINE) {
+			this.parseHeadline(packet, account);
+			return;
+		}
+		if ((message == null) || (message.getBody() == null)) {
+			return;
+		}
+		if ((Settings.CONFIRM_MESSAGE_RECEIVED)
+				&& ((packet.getId() != null))) {
+			if (packet.hasChild("markable", "urn:xmpp:chat-markers:0")) {
+				MessagePacket receipt = mXmppConnectionService
+						.getMessageGenerator().received(account, packet,
+								"urn:xmpp:chat-markers:0");
+				mXmppConnectionService.sendMessagePacket(account, receipt);
+			}
+			if (packet.hasChild("request", "urn:xmpp:receipts")) {
+				MessagePacket receipt = mXmppConnectionService
+						.getMessageGenerator().received(account, packet,
+								"urn:xmpp:receipts");
+				mXmppConnectionService.sendMessagePacket(account, receipt);
+			}
+		}
+		Conversation conversation = message.getConversation();
+		conversation.add(message);
+		if (account.getXmppConnection() != null && account.getXmppConnection().getFeatures().advancedStreamFeaturesLoaded()) {
+			if (conversation.setLastMessageTransmitted(System.currentTimeMillis())) {
+				mXmppConnectionService.updateConversation(conversation);
+			}
+		}
+
+		if (message.getStatus() == Message.STATUS_RECEIVED
+				&& conversation.getOtrSession() != null
+				&& !conversation.getOtrSession().getSessionID().getUserID()
+				.equals(message.getCounterpart().getResourcepart())) {
+			conversation.endOtrIfNeeded();
+		}
+
+		if (packet.getType() != MessagePacket.TYPE_ERROR) {
+			if (message.getEncryption() == Message.ENCRYPTION_NONE
+					|| mXmppConnectionService.saveEncryptedMessages()) {
+				mXmppConnectionService.databaseBackend.createMessage(message);
+			}
+		}
+		final HttpConnectionManager manager = this.mXmppConnectionService.getHttpConnectionManager();
+		if (message.trusted()
+                && Settings.DOWNLOAD_IMAGE_LINKS
+                && mXmppConnectionService.isDownloadAllowedInConnection()
+                && message.bodyContainsDownloadable()
+                && manager.getAutoAcceptFileSize() > 0) {
+			manager.createNewConnection(message);
+		} else if (!message.isRead()) {
+			mXmppConnectionService.getNotificationService().push(message);
+		}
+		mXmppConnectionService.updateConversationUi();
+	}
+
+	private void parseHeadline(MessagePacket packet, Account account) {
+		if (packet.hasChild("event", "http://jabber.org/protocol/pubsub#event")) {
+			Element event = packet.findChild("event",
+					"http://jabber.org/protocol/pubsub#event");
+			parseEvent(event, packet.getFrom(), account);
+		}
+	}
+
+	private void parseNick(MessagePacket packet, Account account) {
+		Element nick = packet.findChild("nick",
+				"http://jabber.org/protocol/nick");
+		if (nick != null) {
+			if (packet.getFrom() != null) {
+				Contact contact = account.getRoster().getContact(
+						packet.getFrom());
+				contact.setPresenceName(nick.getContent());
+			}
+		}
+	}
+}
diff --git a/src/main/java/de/thedevstack/conversationsplus/parser/PresenceParser.java b/src/main/java/de/thedevstack/conversationsplus/parser/PresenceParser.java
new file mode 100644
index 00000000..cfa09fd7
--- /dev/null
+++ b/src/main/java/de/thedevstack/conversationsplus/parser/PresenceParser.java
@@ -0,0 +1,118 @@
+package de.thedevstack.conversationsplus.parser;
+
+import java.util.ArrayList;
+
+import de.thedevstack.conversationsplus.crypto.PgpEngine;
+import de.thedevstack.conversationsplus.entities.Account;
+import de.thedevstack.conversationsplus.entities.Contact;
+import de.thedevstack.conversationsplus.entities.Conversation;
+import de.thedevstack.conversationsplus.entities.MucOptions;
+import de.thedevstack.conversationsplus.entities.Presences;
+import de.thedevstack.conversationsplus.generator.PresenceGenerator;
+import de.thedevstack.conversationsplus.services.XmppConnectionService;
+import de.thedevstack.conversationsplus.xml.Element;
+import de.thedevstack.conversationsplus.xmpp.OnPresencePacketReceived;
+import de.thedevstack.conversationsplus.xmpp.jid.Jid;
+import de.thedevstack.conversationsplus.xmpp.stanzas.PresencePacket;
+
+public class PresenceParser extends AbstractParser implements
+		OnPresencePacketReceived {
+
+	public PresenceParser(XmppConnectionService service) {
+		super(service);
+	}
+
+	public void parseConferencePresence(PresencePacket packet, Account account) {
+		PgpEngine mPgpEngine = mXmppConnectionService.getPgpEngine();
+		final Conversation conversation = packet.getFrom() == null ? null : mXmppConnectionService.find(account, packet.getFrom().toBareJid());
+		if (conversation != null) {
+			final MucOptions mucOptions = conversation.getMucOptions();
+			boolean before = mucOptions.online();
+			int count = mucOptions.getUsers().size();
+			final ArrayList<MucOptions.User> tileUserBefore = new ArrayList<>(mucOptions.getUsers().subList(0,Math.min(mucOptions.getUsers().size(),5)));
+			mucOptions.processPacket(packet, mPgpEngine);
+			final ArrayList<MucOptions.User> tileUserAfter = new ArrayList<>(mucOptions.getUsers().subList(0,Math.min(mucOptions.getUsers().size(),5)));
+			if (!tileUserAfter.equals(tileUserBefore)) {
+				mXmppConnectionService.getAvatarService().clear(conversation);
+			}
+			if (before != mucOptions.online() || (mucOptions.online() && count != mucOptions.getUsers().size())) {
+				mXmppConnectionService.updateConversationUi();
+			} else if (mucOptions.online()) {
+				mXmppConnectionService.updateMucRosterUi();
+			}
+		}
+	}
+
+	public void parseContactPresence(PresencePacket packet, Account account) {
+		PresenceGenerator mPresenceGenerator = mXmppConnectionService
+				.getPresenceGenerator();
+		if (packet.getFrom() == null) {
+			return;
+		}
+		final Jid from = packet.getFrom();
+		String type = packet.getAttribute("type");
+		Contact contact = account.getRoster().getContact(packet.getFrom());
+		if (type == null) {
+			String presence;
+			if (!from.isBareJid()) {
+				presence = from.getResourcepart();
+			} else {
+				presence = "";
+			}
+			int sizeBefore = contact.getPresences().size();
+			contact.updatePresence(presence,
+					Presences.parseShow(packet.findChild("show")));
+			PgpEngine pgp = mXmppConnectionService.getPgpEngine();
+			if (pgp != null) {
+				Element x = packet.findChild("x", "jabber:x:signed");
+				if (x != null) {
+					Element status = packet.findChild("status");
+					String msg;
+					if (status != null) {
+						msg = status.getContent();
+					} else {
+						msg = "";
+					}
+					contact.setPgpKeyId(pgp.fetchKeyId(account, msg,
+							x.getContent()));
+				}
+			}
+			boolean online = sizeBefore < contact.getPresences().size();
+			updateLastseen(packet, account, false);
+			mXmppConnectionService.onContactStatusChanged.onContactStatusChanged(contact, online);
+		} else if (type.equals("unavailable")) {
+			if (from.isBareJid()) {
+				contact.clearPresences();
+			} else {
+				contact.removePresence(from.getResourcepart());
+			}
+			mXmppConnectionService.onContactStatusChanged
+					.onContactStatusChanged(contact, false);
+		} else if (type.equals("subscribe")) {
+			if (contact.getOption(Contact.Options.PREEMPTIVE_GRANT)) {
+				mXmppConnectionService.sendPresencePacket(account,
+						mPresenceGenerator.sendPresenceUpdatesTo(contact));
+			} else {
+				contact.setOption(Contact.Options.PENDING_SUBSCRIPTION_REQUEST);
+			}
+		}
+		Element nick = packet.findChild("nick",
+				"http://jabber.org/protocol/nick");
+		if (nick != null) {
+			contact.setPresenceName(nick.getContent());
+		}
+		mXmppConnectionService.updateRosterUi();
+	}
+
+	@Override
+	public void onPresencePacketReceived(Account account, PresencePacket packet) {
+		if (packet.hasChild("x", "http://jabber.org/protocol/muc#user")) {
+			this.parseConferencePresence(packet, account);
+		} else if (packet.hasChild("x", "http://jabber.org/protocol/muc")) {
+			this.parseConferencePresence(packet, account);
+		} else {
+			this.parseContactPresence(packet, account);
+		}
+	}
+
+}