changed package id inside manifest and project

4 files changed, 796 insertions, 0 deletions

diff --git a/src/main/java/de/pixart/messenger/generator/AbstractGenerator.java b/src/main/java/de/pixart/messenger/generator/AbstractGenerator.java
new file mode 100644
index 000000000..bb68dae7b
--- /dev/null
+++ b/src/main/java/de/pixart/messenger/generator/AbstractGenerator.java
@@ -0,0 +1,128 @@
+package de.pixart.messenger.generator;
+
+import android.util.Base64;
+
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Locale;
+import java.util.TimeZone;
+
+import de.pixart.messenger.Config;
+import de.pixart.messenger.R;
+import de.pixart.messenger.crypto.axolotl.AxolotlService;
+import de.pixart.messenger.services.XmppConnectionService;
+import de.pixart.messenger.utils.PhoneHelper;
+import de.pixart.messenger.xmpp.jingle.stanzas.Content;
+
+public abstract class AbstractGenerator {
+	private final String[] FEATURES = {
+			"urn:xmpp:jingle:1",
+			Content.Version.FT_3.getNamespace(),
+			Content.Version.FT_4.getNamespace(),
+			"urn:xmpp:jingle:transports:s5b:1",
+			"urn:xmpp:jingle:transports:ibb:1",
+			"http://jabber.org/protocol/muc",
+			"jabber:x:conference",
+			"http://jabber.org/protocol/caps",
+			"http://jabber.org/protocol/disco#info",
+			"urn:xmpp:avatar:metadata+notify",
+			"http://jabber.org/protocol/nick+notify",
+			"urn:xmpp:ping",
+			"jabber:iq:version",
+			"http://jabber.org/protocol/chatstates"
+	};
+	private final String[] MESSAGE_CONFIRMATION_FEATURES = {
+			"urn:xmpp:chat-markers:0",
+			"urn:xmpp:receipts"
+	};
+	private final String[] MESSAGE_CORRECTION_FEATURES = {
+			"urn:xmpp:message-correct:0"
+	};
+	private final String[] PRIVACY_SENSITIVE = {
+			"urn:xmpp:time" //XEP-0202: Entity Time leaks time zone
+	};
+	private final String[] OTR = {
+			"urn:xmpp:otr:0"
+	};
+	private String mVersion = null;
+
+	private String mVersionOs = null;
+
+	protected final String IDENTITY_TYPE = "phone";
+
+	private static final SimpleDateFormat DATE_FORMAT = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'", Locale.US);
+
+	protected XmppConnectionService mXmppConnectionService;
+
+	protected AbstractGenerator(XmppConnectionService service) {
+		this.mXmppConnectionService = service;
+	}
+
+	protected String getIdentityVersion() {
+		if (mVersion == null) {
+			this.mVersion = PhoneHelper.getVersionName(mXmppConnectionService);
+		}
+		return this.mVersion;
+	}
+
+	protected String getIdentityVersionOs() {
+		if (mVersionOs == null) {
+			this.mVersionOs = "Android/" + android.os.Build.MODEL
+					+ "/" + android.os.Build.VERSION.RELEASE;
+		}
+		return this.mVersionOs;
+	}
+
+	public String getIdentityName() {
+		return mXmppConnectionService.getString(R.string.app_name) + " " + getIdentityVersion();
+	}
+
+	public String getCapHash() {
+		StringBuilder s = new StringBuilder();
+		s.append("client/" + IDENTITY_TYPE + "//" + getIdentityName() + "<");
+		MessageDigest md;
+		try {
+			md = MessageDigest.getInstance("SHA-1");
+		} catch (NoSuchAlgorithmException e) {
+			return null;
+		}
+
+		for (String feature : getFeatures()) {
+			s.append(feature + "<");
+		}
+		byte[] sha1 = md.digest(s.toString().getBytes());
+		return new String(Base64.encode(sha1, Base64.DEFAULT)).trim();
+	}
+
+	public static String getTimestamp(long time) {
+		DATE_FORMAT.setTimeZone(TimeZone.getTimeZone("UTC"));
+		return DATE_FORMAT.format(time);
+	}
+
+	public List<String> getFeatures() {
+		ArrayList<String> features = new ArrayList<>();
+		features.addAll(Arrays.asList(FEATURES));
+		if (mXmppConnectionService.confirmMessages()) {
+			features.addAll(Arrays.asList(MESSAGE_CONFIRMATION_FEATURES));
+		}
+		if (mXmppConnectionService.allowMessageCorrection()) {
+			features.addAll(Arrays.asList(MESSAGE_CORRECTION_FEATURES));
+		}
+		if (Config.supportOmemo()) {
+			features.add(AxolotlService.PEP_DEVICE_LIST_NOTIFY);
+		}
+		if (!mXmppConnectionService.useTorToConnect()) {
+			features.addAll(Arrays.asList(PRIVACY_SENSITIVE));
+		}
+		if (Config.supportOtr()) {
+			features.addAll(Arrays.asList(OTR));
+		}
+		Collections.sort(features);
+		return features;
+	}
+}
diff --git a/src/main/java/de/pixart/messenger/generator/IqGenerator.java b/src/main/java/de/pixart/messenger/generator/IqGenerator.java
new file mode 100644
index 000000000..b8d79d953
--- /dev/null
+++ b/src/main/java/de/pixart/messenger/generator/IqGenerator.java
@@ -0,0 +1,376 @@
+package de.pixart.messenger.generator;
+
+
+import android.os.Bundle;
+import android.util.Base64;
+import android.util.Log;
+
+import org.whispersystems.libaxolotl.IdentityKey;
+import org.whispersystems.libaxolotl.ecc.ECPublicKey;
+import org.whispersystems.libaxolotl.state.PreKeyRecord;
+import org.whispersystems.libaxolotl.state.SignedPreKeyRecord;
+
+import java.security.cert.CertificateEncodingException;
+import java.security.cert.X509Certificate;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+import java.util.TimeZone;
+
+import de.pixart.messenger.Config;
+import de.pixart.messenger.R;
+import de.pixart.messenger.crypto.axolotl.AxolotlService;
+import de.pixart.messenger.entities.Account;
+import de.pixart.messenger.entities.Conversation;
+import de.pixart.messenger.entities.DownloadableFile;
+import de.pixart.messenger.services.MessageArchiveService;
+import de.pixart.messenger.services.XmppConnectionService;
+import de.pixart.messenger.utils.Xmlns;
+import de.pixart.messenger.xml.Element;
+import de.pixart.messenger.xmpp.forms.Data;
+import de.pixart.messenger.xmpp.jid.Jid;
+import de.pixart.messenger.xmpp.pep.Avatar;
+import de.pixart.messenger.xmpp.stanzas.IqPacket;
+
+public class IqGenerator extends AbstractGenerator {
+
+	public IqGenerator(final XmppConnectionService service) {
+		super(service);
+	}
+
+	public IqPacket discoResponse(final IqPacket request) {
+		final IqPacket packet = new IqPacket(IqPacket.TYPE.RESULT);
+		packet.setId(request.getId());
+		packet.setTo(request.getFrom());
+		final Element query = packet.addChild("query",
+				"http://jabber.org/protocol/disco#info");
+		query.setAttribute("node", request.query().getAttribute("node"));
+		final Element identity = query.addChild("identity");
+		identity.setAttribute("category", "client");
+		identity.setAttribute("type", IDENTITY_TYPE);
+		identity.setAttribute("name", getIdentityName());
+		for (final String feature : getFeatures()) {
+			query.addChild("feature").setAttribute("var", feature);
+		}
+		return packet;
+	}
+
+	public IqPacket versionResponse(final IqPacket request) {
+		final IqPacket packet = request.generateResponse(IqPacket.TYPE.RESULT);
+		Element query = packet.query("jabber:iq:version");
+		query.addChild("name").setContent(mXmppConnectionService.getString(R.string.app_name));
+		query.addChild("version").setContent(getIdentityVersion());
+		if ("chromium".equals(android.os.Build.BRAND)) {
+			query.addChild("os").setContent("Chromium");
+		} else{
+			query.addChild("os").setContent("Android");
+		}
+		return packet;
+	}
+
+	public IqPacket entityTimeResponse(IqPacket request) {
+		final IqPacket packet = request.generateResponse(IqPacket.TYPE.RESULT);
+		Element time = packet.addChild("time","urn:xmpp:time");
+		final long now = System.currentTimeMillis();
+		time.addChild("utc").setContent(getTimestamp(now));
+		TimeZone ourTimezone = TimeZone.getDefault();
+		long offsetSeconds = ourTimezone.getOffset(now) / 1000;
+		long offsetMinutes = offsetSeconds % (60 * 60);
+		long offsetHours = offsetSeconds / (60 * 60);
+		time.addChild("tzo").setContent(String.format("%02d",offsetHours)+":"+String.format("%02d",offsetMinutes));
+		return packet;
+	}
+
+	protected IqPacket publish(final String node, final Element item) {
+		final IqPacket packet = new IqPacket(IqPacket.TYPE.SET);
+		final Element pubsub = packet.addChild("pubsub",
+				"http://jabber.org/protocol/pubsub");
+		final Element publish = pubsub.addChild("publish");
+		publish.setAttribute("node", node);
+		publish.addChild(item);
+		return packet;
+	}
+
+	protected IqPacket retrieve(String node, Element item) {
+		final IqPacket packet = new IqPacket(IqPacket.TYPE.GET);
+		final Element pubsub = packet.addChild("pubsub",
+				"http://jabber.org/protocol/pubsub");
+		final Element items = pubsub.addChild("items");
+		items.setAttribute("node", node);
+		if (item != null) {
+			items.addChild(item);
+		}
+		return packet;
+	}
+
+	public IqPacket publishNick(String nick) {
+		final Element item = new Element("item");
+		item.addChild("nick","http://jabber.org/protocol/nick").setContent(nick);
+		return publish("http://jabber.org/protocol/nick", item);
+	}
+
+	public IqPacket publishAvatar(Avatar avatar) {
+		final Element item = new Element("item");
+		item.setAttribute("id", avatar.sha1sum);
+		final Element data = item.addChild("data", "urn:xmpp:avatar:data");
+		data.setContent(avatar.image);
+		return publish("urn:xmpp:avatar:data", item);
+	}
+
+	public IqPacket publishAvatarMetadata(final Avatar avatar) {
+		final Element item = new Element("item");
+		item.setAttribute("id", avatar.sha1sum);
+		final Element metadata = item
+			.addChild("metadata", "urn:xmpp:avatar:metadata");
+		final Element info = metadata.addChild("info");
+		info.setAttribute("bytes", avatar.size);
+		info.setAttribute("id", avatar.sha1sum);
+		info.setAttribute("height", avatar.height);
+		info.setAttribute("width", avatar.height);
+		info.setAttribute("type", avatar.type);
+		return publish("urn:xmpp:avatar:metadata", item);
+	}
+
+	public IqPacket retrievePepAvatar(final Avatar avatar) {
+		final Element item = new Element("item");
+		item.setAttribute("id", avatar.sha1sum);
+		final IqPacket packet = retrieve("urn:xmpp:avatar:data", item);
+		packet.setTo(avatar.owner);
+		return packet;
+	}
+
+	public IqPacket retrieveVcardAvatar(final Avatar avatar) {
+		final IqPacket packet = new IqPacket(IqPacket.TYPE.GET);
+		packet.setTo(avatar.owner);
+		packet.addChild("vCard", "vcard-temp");
+		return packet;
+	}
+
+	public IqPacket retrieveAvatarMetaData(final Jid to) {
+		final IqPacket packet = retrieve("urn:xmpp:avatar:metadata", null);
+		if (to != null) {
+			packet.setTo(to);
+		}
+		return packet;
+	}
+
+	public IqPacket retrieveDeviceIds(final Jid to) {
+		final IqPacket packet = retrieve(AxolotlService.PEP_DEVICE_LIST, null);
+		if(to != null) {
+			packet.setTo(to);
+		}
+		return packet;
+	}
+
+	public IqPacket retrieveBundlesForDevice(final Jid to, final int deviceid) {
+		final IqPacket packet = retrieve(AxolotlService.PEP_BUNDLES+":"+deviceid, null);
+		packet.setTo(to);
+		return packet;
+	}
+
+	public IqPacket retrieveVerificationForDevice(final Jid to, final int deviceid) {
+		final IqPacket packet = retrieve(AxolotlService.PEP_VERIFICATION+":"+deviceid, null);
+		packet.setTo(to);
+		return packet;
+	}
+
+	public IqPacket publishDeviceIds(final Set<Integer> ids) {
+		final Element item = new Element("item");
+		final Element list = item.addChild("list", AxolotlService.PEP_PREFIX);
+		for(Integer id:ids) {
+			final Element device = new Element("device");
+			device.setAttribute("id", id);
+			list.addChild(device);
+		}
+		return publish(AxolotlService.PEP_DEVICE_LIST, item);
+	}
+
+	public IqPacket publishBundles(final SignedPreKeyRecord signedPreKeyRecord, final IdentityKey identityKey,
+	                               final Set<PreKeyRecord> preKeyRecords, final int deviceId) {
+		final Element item = new Element("item");
+		final Element bundle = item.addChild("bundle", AxolotlService.PEP_PREFIX);
+		final Element signedPreKeyPublic = bundle.addChild("signedPreKeyPublic");
+		signedPreKeyPublic.setAttribute("signedPreKeyId", signedPreKeyRecord.getId());
+		ECPublicKey publicKey = signedPreKeyRecord.getKeyPair().getPublicKey();
+		signedPreKeyPublic.setContent(Base64.encodeToString(publicKey.serialize(),Base64.DEFAULT));
+		final Element signedPreKeySignature = bundle.addChild("signedPreKeySignature");
+		signedPreKeySignature.setContent(Base64.encodeToString(signedPreKeyRecord.getSignature(),Base64.DEFAULT));
+		final Element identityKeyElement = bundle.addChild("identityKey");
+		identityKeyElement.setContent(Base64.encodeToString(identityKey.serialize(), Base64.DEFAULT));
+
+		final Element prekeys = bundle.addChild("prekeys", AxolotlService.PEP_PREFIX);
+		for(PreKeyRecord preKeyRecord:preKeyRecords) {
+			final Element prekey = prekeys.addChild("preKeyPublic");
+			prekey.setAttribute("preKeyId", preKeyRecord.getId());
+			prekey.setContent(Base64.encodeToString(preKeyRecord.getKeyPair().getPublicKey().serialize(), Base64.DEFAULT));
+		}
+
+		return publish(AxolotlService.PEP_BUNDLES+":"+deviceId, item);
+	}
+
+	public IqPacket publishVerification(byte[] signature, X509Certificate[] certificates, final int deviceId) {
+		final Element item = new Element("item");
+		final Element verification = item.addChild("verification", AxolotlService.PEP_PREFIX);
+		final Element chain = verification.addChild("chain");
+		for(int i = 0; i < certificates.length; ++i) {
+			try {
+				Element certificate = chain.addChild("certificate");
+				certificate.setContent(Base64.encodeToString(certificates[i].getEncoded(), Base64.DEFAULT));
+				certificate.setAttribute("index",i);
+			} catch (CertificateEncodingException e) {
+				Log.d(Config.LOGTAG, "could not encode certificate");
+			}
+		}
+		verification.addChild("signature").setContent(Base64.encodeToString(signature, Base64.DEFAULT));
+		return publish(AxolotlService.PEP_VERIFICATION+":"+deviceId, item);
+	}
+
+	public IqPacket queryMessageArchiveManagement(final MessageArchiveService.Query mam) {
+		final IqPacket packet = new IqPacket(IqPacket.TYPE.SET);
+		final Element query = packet.query("urn:xmpp:mam:0");
+		query.setAttribute("queryid", mam.getQueryId());
+		final Data data = new Data();
+		data.setFormType("urn:xmpp:mam:0");
+		if (mam.muc()) {
+			packet.setTo(mam.getWith());
+		} else if (mam.getWith()!=null) {
+			data.put("with", mam.getWith().toString());
+		}
+		data.put("start", getTimestamp(mam.getStart()));
+		data.put("end", getTimestamp(mam.getEnd()));
+		data.submit();
+		query.addChild(data);
+		if (mam.getPagingOrder() == MessageArchiveService.PagingOrder.REVERSE) {
+			query.addChild("set", "http://jabber.org/protocol/rsm").addChild("before").setContent(mam.getReference());
+		} else if (mam.getReference() != null) {
+			query.addChild("set", "http://jabber.org/protocol/rsm").addChild("after").setContent(mam.getReference());
+		}
+		return packet;
+	}
+	public IqPacket generateGetBlockList() {
+		final IqPacket iq = new IqPacket(IqPacket.TYPE.GET);
+		iq.addChild("blocklist", Xmlns.BLOCKING);
+
+		return iq;
+	}
+
+	public IqPacket generateSetBlockRequest(final Jid jid) {
+		final IqPacket iq = new IqPacket(IqPacket.TYPE.SET);
+		final Element block = iq.addChild("block", Xmlns.BLOCKING);
+		block.addChild("item").setAttribute("jid", jid.toBareJid().toString());
+		return iq;
+	}
+
+	public IqPacket generateSetUnblockRequest(final Jid jid) {
+		final IqPacket iq = new IqPacket(IqPacket.TYPE.SET);
+		final Element block = iq.addChild("unblock", Xmlns.BLOCKING);
+		block.addChild("item").setAttribute("jid", jid.toBareJid().toString());
+		return iq;
+	}
+
+	public IqPacket generateSetPassword(final Account account, final String newPassword) {
+		final IqPacket packet = new IqPacket(IqPacket.TYPE.SET);
+		packet.setTo(account.getServer());
+		final Element query = packet.addChild("query", Xmlns.REGISTER);
+		final Jid jid = account.getJid();
+		query.addChild("username").setContent(jid.getLocalpart());
+		query.addChild("password").setContent(newPassword);
+		return packet;
+	}
+
+	public IqPacket changeAffiliation(Conversation conference, Jid jid, String affiliation) {
+		List<Jid> jids = new ArrayList<>();
+		jids.add(jid);
+		return changeAffiliation(conference,jids,affiliation);
+	}
+
+	public IqPacket changeAffiliation(Conversation conference, List<Jid> jids, String affiliation) {
+		IqPacket packet = new IqPacket(IqPacket.TYPE.SET);
+		packet.setTo(conference.getJid().toBareJid());
+		packet.setFrom(conference.getAccount().getJid());
+		Element query = packet.query("http://jabber.org/protocol/muc#admin");
+		for(Jid jid : jids) {
+			Element item = query.addChild("item");
+			item.setAttribute("jid", jid.toString());
+			item.setAttribute("affiliation", affiliation);
+		}
+		return packet;
+	}
+
+	public IqPacket changeRole(Conversation conference, String nick, String role) {
+		IqPacket packet = new IqPacket(IqPacket.TYPE.SET);
+		packet.setTo(conference.getJid().toBareJid());
+		packet.setFrom(conference.getAccount().getJid());
+		Element item = packet.query("http://jabber.org/protocol/muc#admin").addChild("item");
+		item.setAttribute("nick", nick);
+		item.setAttribute("role", role);
+		return packet;
+	}
+
+	public IqPacket requestHttpUploadSlot(Jid host, DownloadableFile file, String mime) {
+		IqPacket packet = new IqPacket(IqPacket.TYPE.GET);
+		packet.setTo(host);
+		Element request = packet.addChild("request", Xmlns.HTTP_UPLOAD);
+		request.addChild("filename").setContent(file.getName());
+		request.addChild("size").setContent(String.valueOf(file.getExpectedSize()));
+		if (mime != null) {
+			request.addChild("content-type").setContent(mime);
+		}
+		return packet;
+	}
+
+	public IqPacket generateCreateAccountWithCaptcha(Account account, String id, Data data) {
+		final IqPacket register = new IqPacket(IqPacket.TYPE.SET);
+
+		register.setTo(account.getServer());
+		register.setId(id);
+		Element query = register.query("jabber:iq:register");
+		if (data != null) {
+			query.addChild(data);
+		}
+		return register;
+	}
+
+	public IqPacket pushTokenToAppServer(Jid appServer, String token, String deviceId) {
+		IqPacket packet = new IqPacket(IqPacket.TYPE.SET);
+		packet.setTo(appServer);
+		Element command = packet.addChild("command", "http://jabber.org/protocol/commands");
+		command.setAttribute("node","register-push-gcm");
+		command.setAttribute("action","execute");
+		Data data = new Data();
+		data.put("token", token);
+		data.put("device-id", deviceId);
+		data.submit();
+		command.addChild(data);
+		return packet;
+	}
+
+	public IqPacket enablePush(Jid jid, String node, String secret) {
+		IqPacket packet = new IqPacket(IqPacket.TYPE.SET);
+		Element enable = packet.addChild("enable","urn:xmpp:push:0");
+		enable.setAttribute("jid",jid.toString());
+		enable.setAttribute("node", node);
+		Data data = new Data();
+		data.setFormType("http://jabber.org/protocol/pubsub#publish-options");
+		data.put("secret",secret);
+		data.submit();
+		enable.addChild(data);
+		return packet;
+	}
+
+	public IqPacket queryAffiliation(Conversation conversation, String affiliation) {
+		IqPacket packet = new IqPacket(IqPacket.TYPE.GET);
+		packet.setTo(conversation.getJid().toBareJid());
+		packet.query("http://jabber.org/protocol/muc#admin").addChild("item").setAttribute("affiliation",affiliation);
+		return packet;
+	}
+
+	public static Bundle defaultRoomConfiguration() {
+		Bundle options = new Bundle();
+		options.putString("muc#roomconfig_persistentroom", "1");
+		options.putString("muc#roomconfig_membersonly", "1");
+		options.putString("muc#roomconfig_publicroom", "0");
+		options.putString("muc#roomconfig_whois", "anyone");
+		return options;
+	}
+}
diff --git a/src/main/java/de/pixart/messenger/generator/MessageGenerator.java b/src/main/java/de/pixart/messenger/generator/MessageGenerator.java
new file mode 100644
index 000000000..bf64f5bfd
--- /dev/null
+++ b/src/main/java/de/pixart/messenger/generator/MessageGenerator.java
@@ -0,0 +1,225 @@
+package de.pixart.messenger.generator;
+
+import net.java.otr4j.OtrException;
+import net.java.otr4j.session.Session;
+
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.Locale;
+import java.util.TimeZone;
+
+import de.pixart.messenger.Config;
+import de.pixart.messenger.crypto.axolotl.AxolotlService;
+import de.pixart.messenger.crypto.axolotl.XmppAxolotlMessage;
+import de.pixart.messenger.entities.Account;
+import de.pixart.messenger.entities.Contact;
+import de.pixart.messenger.entities.Conversation;
+import de.pixart.messenger.entities.Message;
+import de.pixart.messenger.services.XmppConnectionService;
+import de.pixart.messenger.xml.Element;
+import de.pixart.messenger.xmpp.chatstate.ChatState;
+import de.pixart.messenger.xmpp.jid.Jid;
+import de.pixart.messenger.xmpp.stanzas.MessagePacket;
+
+public class MessageGenerator extends AbstractGenerator {
+	public static final String OTR_FALLBACK_MESSAGE = "I would like to start a private (OTR encrypted) conversation but your client doesn’t seem to support that";
+	private static final String OMEMO_FALLBACK_MESSAGE = "I sent you an OMEMO encrypted message but your client doesn’t seem to support that. Find more information on https://conversations.im/omemo";
+	private static final String PGP_FALLBACK_MESSAGE = "I sent you a PGP encrypted message but your client doesn’t seem to support that.";
+
+	public MessageGenerator(XmppConnectionService service) {
+		super(service);
+	}
+
+	private MessagePacket preparePacket(Message message) {
+		Conversation conversation = message.getConversation();
+		Account account = conversation.getAccount();
+		MessagePacket packet = new MessagePacket();
+		if (conversation.getMode() == Conversation.MODE_SINGLE) {
+			packet.setTo(message.getCounterpart());
+			packet.setType(MessagePacket.TYPE_CHAT);
+			packet.addChild("markable", "urn:xmpp:chat-markers:0");
+			if (this.mXmppConnectionService.indicateReceived()) {
+				packet.addChild("request", "urn:xmpp:receipts");
+			}
+		} else if (message.getType() == Message.TYPE_PRIVATE) {
+			packet.setTo(message.getCounterpart());
+			packet.setType(MessagePacket.TYPE_CHAT);
+			if (this.mXmppConnectionService.indicateReceived()) {
+				packet.addChild("request", "urn:xmpp:receipts");
+			}
+		} else {
+			packet.setTo(message.getCounterpart().toBareJid());
+			packet.setType(MessagePacket.TYPE_GROUPCHAT);
+		}
+		packet.setFrom(account.getJid());
+		packet.setId(message.getUuid());
+		if (message.edited()) {
+			packet.addChild("replace","urn:xmpp:message-correct:0").setAttribute("id",message.getEditedId());
+		}
+		return packet;
+	}
+
+	public void addDelay(MessagePacket packet, long timestamp) {
+		final SimpleDateFormat mDateFormat = new SimpleDateFormat(
+				"yyyy-MM-dd'T'HH:mm:ss.SSS'Z'", Locale.US);
+		mDateFormat.setTimeZone(TimeZone.getTimeZone("UTC"));
+		Element delay = packet.addChild("delay", "urn:xmpp:delay");
+		Date date = new Date(timestamp);
+		delay.setAttribute("stamp", mDateFormat.format(date));
+	}
+
+	public MessagePacket generateAxolotlChat(Message message, XmppAxolotlMessage axolotlMessage) {
+		MessagePacket packet = preparePacket(message);
+		if (axolotlMessage == null) {
+			return null;
+		}
+		packet.setAxolotlMessage(axolotlMessage.toElement());
+		if (Config.supportUnencrypted() && !recipientSupportsOmemo(message)) {
+			packet.setBody(OMEMO_FALLBACK_MESSAGE);
+		}
+		packet.addChild("store", "urn:xmpp:hints");
+		return packet;
+	}
+
+	private static boolean recipientSupportsOmemo(Message message) {
+		Contact c = message.getContact();
+		return c != null && c.getPresences().allOrNonSupport(AxolotlService.PEP_DEVICE_LIST_NOTIFY);
+	}
+
+	public static void addMessageHints(MessagePacket packet) {
+		packet.addChild("private", "urn:xmpp:carbons:2");
+		packet.addChild("no-copy", "urn:xmpp:hints");
+		packet.addChild("no-permanent-store", "urn:xmpp:hints");
+		packet.addChild("no-permanent-storage", "urn:xmpp:hints"); //do not copy this. this is wrong. it is *store*
+	}
+
+	public MessagePacket generateOtrChat(Message message) {
+		Session otrSession = message.getConversation().getOtrSession();
+		if (otrSession == null) {
+			return null;
+		}
+		MessagePacket packet = preparePacket(message);
+		addMessageHints(packet);
+		try {
+			String content;
+			if (message.hasFileOnRemoteHost()) {
+				content = message.getFileParams().url.toString();
+			} else {
+				content = message.getBody();
+			}
+			packet.setBody(otrSession.transformSending(content)[0]);
+			return packet;
+		} catch (OtrException e) {
+			return null;
+		}
+	}
+
+	public MessagePacket generateChat(Message message) {
+		MessagePacket packet = preparePacket(message);
+		String content;
+		if (message.hasFileOnRemoteHost()) {
+			Message.FileParams fileParams = message.getFileParams();
+			content = fileParams.url.toString();
+			packet.addChild("x","jabber:x:oob").addChild("url").setContent(content);
+		} else {
+			content = message.getBody();
+		}
+		packet.setBody(content);
+		return packet;
+	}
+
+	public MessagePacket generatePgpChat(Message message) {
+		MessagePacket packet = preparePacket(message);
+		if (Config.supportUnencrypted()) {
+			packet.setBody(PGP_FALLBACK_MESSAGE);
+		}
+		if (message.getEncryption() == Message.ENCRYPTION_DECRYPTED) {
+			packet.addChild("x", "jabber:x:encrypted").setContent(message.getEncryptedBody());
+		} else if (message.getEncryption() == Message.ENCRYPTION_PGP) {
+			packet.addChild("x", "jabber:x:encrypted").setContent(message.getBody());
+		}
+		return packet;
+	}
+
+	public MessagePacket generateChatState(Conversation conversation) {
+		final Account account = conversation.getAccount();
+		MessagePacket packet = new MessagePacket();
+		packet.setType(MessagePacket.TYPE_CHAT);
+		packet.setTo(conversation.getJid().toBareJid());
+		packet.setFrom(account.getJid());
+		packet.addChild(ChatState.toElement(conversation.getOutgoingChatState()));
+		packet.addChild("no-store", "urn:xmpp:hints");
+		packet.addChild("no-storage", "urn:xmpp:hints"); //wrong! don't copy this. Its *store*
+		return packet;
+	}
+
+	public MessagePacket confirm(final Account account, final Jid to, final String id) {
+		MessagePacket packet = new MessagePacket();
+		packet.setType(MessagePacket.TYPE_CHAT);
+		packet.setTo(to);
+		packet.setFrom(account.getJid());
+		Element received = packet.addChild("displayed","urn:xmpp:chat-markers:0");
+		received.setAttribute("id", id);
+		packet.addChild("store", "urn:xmpp:hints");
+		return packet;
+	}
+
+	public MessagePacket conferenceSubject(Conversation conversation,String subject) {
+		MessagePacket packet = new MessagePacket();
+		packet.setType(MessagePacket.TYPE_GROUPCHAT);
+		packet.setTo(conversation.getJid().toBareJid());
+		Element subjectChild = new Element("subject");
+		subjectChild.setContent(subject);
+		packet.addChild(subjectChild);
+		packet.setFrom(conversation.getAccount().getJid().toBareJid());
+		return packet;
+	}
+
+	public MessagePacket directInvite(final Conversation conversation, final Jid contact) {
+		MessagePacket packet = new MessagePacket();
+		packet.setType(MessagePacket.TYPE_NORMAL);
+		packet.setTo(contact);
+		packet.setFrom(conversation.getAccount().getJid());
+		Element x = packet.addChild("x", "jabber:x:conference");
+		x.setAttribute("jid", conversation.getJid().toBareJid().toString());
+		return packet;
+	}
+
+	public MessagePacket invite(Conversation conversation, Jid contact) {
+		MessagePacket packet = new MessagePacket();
+		packet.setTo(conversation.getJid().toBareJid());
+		packet.setFrom(conversation.getAccount().getJid());
+		Element x = new Element("x");
+		x.setAttribute("xmlns", "http://jabber.org/protocol/muc#user");
+		Element invite = new Element("invite");
+		invite.setAttribute("to", contact.toBareJid().toString());
+		x.addChild(invite);
+		packet.addChild(x);
+		return packet;
+	}
+
+	public MessagePacket received(Account account, MessagePacket originalMessage, ArrayList<String> namespaces, int type) {
+		MessagePacket receivedPacket = new MessagePacket();
+		receivedPacket.setType(type);
+		receivedPacket.setTo(originalMessage.getFrom());
+		receivedPacket.setFrom(account.getJid());
+		for(String namespace : namespaces) {
+			receivedPacket.addChild("received", namespace).setAttribute("id", originalMessage.getId());
+		}
+		return receivedPacket;
+	}
+
+	public MessagePacket generateOtrError(Jid to, String id, String errorText) {
+		MessagePacket packet = new MessagePacket();
+		packet.setType(MessagePacket.TYPE_ERROR);
+		packet.setAttribute("id",id);
+		packet.setTo(to);
+		Element error = packet.addChild("error");
+		error.setAttribute("code","406");
+		error.setAttribute("type","modify");
+		error.addChild("not-acceptable","urn:ietf:params:xml:ns:xmpp-stanzas");
+		error.addChild("text").setContent("?OTR Error:" + errorText);
+		return packet;
+	}
+}
diff --git a/src/main/java/de/pixart/messenger/generator/PresenceGenerator.java b/src/main/java/de/pixart/messenger/generator/PresenceGenerator.java
new file mode 100644
index 000000000..b20a4b34e
--- /dev/null
+++ b/src/main/java/de/pixart/messenger/generator/PresenceGenerator.java
@@ -0,0 +1,67 @@
+package de.pixart.messenger.generator;
+
+import de.pixart.messenger.entities.Account;
+import de.pixart.messenger.entities.Contact;
+import de.pixart.messenger.entities.Presence;
+import de.pixart.messenger.services.XmppConnectionService;
+import de.pixart.messenger.xml.Element;
+import de.pixart.messenger.xmpp.stanzas.PresencePacket;
+
+public class PresenceGenerator extends AbstractGenerator {
+
+	public PresenceGenerator(XmppConnectionService service) {
+		super(service);
+	}
+
+	private PresencePacket subscription(String type, Contact contact) {
+		PresencePacket packet = new PresencePacket();
+		packet.setAttribute("type", type);
+		packet.setTo(contact.getJid());
+		packet.setFrom(contact.getAccount().getJid().toBareJid());
+		return packet;
+	}
+
+	public PresencePacket requestPresenceUpdatesFrom(Contact contact) {
+		return subscription("subscribe", contact);
+	}
+
+	public PresencePacket stopPresenceUpdatesFrom(Contact contact) {
+		return subscription("unsubscribe", contact);
+	}
+
+	public PresencePacket stopPresenceUpdatesTo(Contact contact) {
+		return subscription("unsubscribed", contact);
+	}
+
+	public PresencePacket sendPresenceUpdatesTo(Contact contact) {
+		return subscription("subscribed", contact);
+	}
+
+	public PresencePacket selfPresence(Account account, Presence.Status status) {
+		PresencePacket packet = new PresencePacket();
+		if(status.toShowString() != null) {
+			packet.addChild("show").setContent(status.toShowString());
+		}
+		packet.setFrom(account.getJid());
+		String sig = account.getPgpSignature();
+		if (sig != null && mXmppConnectionService.getPgpEngine() != null) {
+			packet.addChild("x", "jabber:x:signed").setContent(sig);
+		}
+		String capHash = getCapHash();
+		if (capHash != null) {
+			Element cap = packet.addChild("c",
+					"http://jabber.org/protocol/caps");
+			cap.setAttribute("hash", "sha-1");
+			cap.setAttribute("node", "http://conversations.im");
+			cap.setAttribute("ver", capHash);
+		}
+		return packet;
+	}
+
+	public PresencePacket sendOfflinePresence(Account account) {
+		PresencePacket packet = new PresencePacket();
+		packet.setFrom(account.getJid());
+		packet.setAttribute("type","unavailable");
+		return packet;
+	}
+}