Updated java.library.path.

briar-android/src/main/java/im/delight/android/identicons/Identicon.java

@@ -0,0 +1,101 @@
+package im.delight.android.identicons;
+
+/**
+ * Copyright 2014 www.delight.im <info@delight.im>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *	  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import android.graphics.Canvas;
+import android.graphics.Color;
+import android.graphics.Paint;
+import android.support.annotation.NonNull;
+import android.support.annotation.UiThread;
+
+import static android.graphics.Paint.Style.FILL;
+
+@UiThread
+class Identicon {
+
+	private static final int ROWS = 9, COLUMNS = 9;
+	private static final int CENTER_COLUMN_INDEX = COLUMNS / 2 + COLUMNS % 2;
+
+	private final byte[] input;
+	private final Paint paint;
+	private final int[][] colors;
+
+	private int cellWidth, cellHeight;
+
+	Identicon(@NonNull byte[] input) {
+		if (input.length == 0) throw new IllegalArgumentException();
+		this.input = input;
+
+		paint = new Paint();
+		paint.setStyle(FILL);
+		paint.setAntiAlias(true);
+		paint.setDither(true);
+
+		colors = new int[ROWS][COLUMNS];
+		int colorVisible = getForegroundColor();
+		int colorInvisible = getBackgroundColor();
+
+		for (int r = 0; r < ROWS; r++) {
+			for (int c = 0; c < COLUMNS; c++) {
+				if (isCellVisible(r, c)) colors[r][c] = colorVisible;
+				else colors[r][c] = colorInvisible;
+			}
+		}
+	}
+
+	private byte getByte(int index) {
+		return input[index % input.length];
+	}
+
+	private boolean isCellVisible(int row, int column) {
+		return getByte(3 + row * CENTER_COLUMN_INDEX +
+				getSymmetricColumnIndex(column)) >= 0;
+	}
+
+	private int getSymmetricColumnIndex(int index) {
+		if (index < CENTER_COLUMN_INDEX) return index;
+		else return COLUMNS - index - 1;
+	}
+
+	private int getForegroundColor() {
+		int r = getByte(0) * 3 / 4 + 96;
+		int g = getByte(1) * 3 / 4 + 96;
+		int b = getByte(2) * 3 / 4 + 96;
+		return Color.rgb(r, g, b);
+	}
+
+	private int getBackgroundColor() {
+		// http://www.google.com/design/spec/style/color.html#color-themes
+		return Color.rgb(0xFA, 0xFA, 0xFA);
+	}
+
+	void updateSize(int w, int h) {
+		cellWidth = w / COLUMNS;
+		cellHeight = h / ROWS;
+	}
+
+	void draw(Canvas canvas) {
+		for (int r = 0; r < ROWS; r++) {
+			for (int c = 0; c < COLUMNS; c++) {
+				int x = cellWidth * c;
+				int y = cellHeight * r;
+				paint.setColor(colors[r][c]);
+				canvas.drawRect(x, y + cellHeight, x + cellWidth, y, paint);
+			}
+		}
+	}
+}

briar-android/src/main/java/im/delight/android/identicons/IdenticonDrawable.java

@@ -0,0 +1,82 @@
+package im.delight.android.identicons;
+
+/**
+ * Copyright 2014 www.delight.im <info@delight.im>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *	  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import android.graphics.Canvas;
+import android.graphics.ColorFilter;
+import android.graphics.Rect;
+import android.graphics.drawable.Drawable;
+import android.support.annotation.NonNull;
+import android.support.annotation.UiThread;
+
+import static android.graphics.PixelFormat.OPAQUE;
+
+@UiThread
+public class IdenticonDrawable extends Drawable {
+
+	private static final int HEIGHT = 200, WIDTH = 200;
+
+	private final Identicon identicon;
+
+	public IdenticonDrawable(@NonNull byte[] input) {
+		super();
+		identicon = new Identicon(input);
+	}
+
+	@Override
+	public int getIntrinsicHeight() {
+		return HEIGHT;
+	}
+
+	@Override
+	public int getIntrinsicWidth() {
+		return WIDTH;
+	}
+
+	@Override
+	public void setBounds(@NonNull Rect bounds) {
+		super.setBounds(bounds);
+		identicon.updateSize(bounds.right - bounds.left,
+				bounds.bottom - bounds.top);
+	}
+
+	@Override
+	public void setBounds(int left, int top, int right, int bottom) {
+		super.setBounds(left, top, right, bottom);
+		identicon.updateSize(right - left, bottom - top);
+	}
+
+	@Override
+	public void draw(@NonNull Canvas canvas) {
+		identicon.draw(canvas);
+	}
+
+	@Override
+	public void setAlpha(int alpha) {
+
+	}
+
+	@Override
+	public void setColorFilter(ColorFilter cf) {
+
+	}
+
+	@Override
+	public int getOpacity() {
+		return OPAQUE;
+	}
+}

briar-android/src/main/java/org/briarproject/briar/android/AndroidComponent.java

@@ -0,0 +1,147 @@
+package org.briarproject.briar.android;
+
+import org.briarproject.bramble.BrambleAndroidModule;
+import org.briarproject.bramble.BrambleCoreEagerSingletons;
+import org.briarproject.bramble.BrambleCoreModule;
+import org.briarproject.bramble.api.contact.ContactExchangeTask;
+import org.briarproject.bramble.api.contact.ContactManager;
+import org.briarproject.bramble.api.crypto.CryptoComponent;
+import org.briarproject.bramble.api.crypto.CryptoExecutor;
+import org.briarproject.bramble.api.crypto.PasswordStrengthEstimator;
+import org.briarproject.bramble.api.db.DatabaseConfig;
+import org.briarproject.bramble.api.db.DatabaseExecutor;
+import org.briarproject.bramble.api.event.EventBus;
+import org.briarproject.bramble.api.identity.IdentityManager;
+import org.briarproject.bramble.api.invitation.InvitationTaskFactory;
+import org.briarproject.bramble.api.keyagreement.KeyAgreementTaskFactory;
+import org.briarproject.bramble.api.keyagreement.PayloadEncoder;
+import org.briarproject.bramble.api.keyagreement.PayloadParser;
+import org.briarproject.bramble.api.lifecycle.IoExecutor;
+import org.briarproject.bramble.api.lifecycle.LifecycleManager;
+import org.briarproject.bramble.api.plugin.ConnectionRegistry;
+import org.briarproject.bramble.api.plugin.PluginManager;
+import org.briarproject.bramble.api.settings.SettingsManager;
+import org.briarproject.bramble.api.system.AndroidExecutor;
+import org.briarproject.bramble.api.system.Clock;
+import org.briarproject.briar.BriarCoreEagerSingletons;
+import org.briarproject.briar.BriarCoreModule;
+import org.briarproject.briar.android.reporting.BriarReportSender;
+import org.briarproject.briar.api.android.AndroidNotificationManager;
+import org.briarproject.briar.api.android.ReferenceManager;
+import org.briarproject.briar.api.blog.BlogManager;
+import org.briarproject.briar.api.blog.BlogPostFactory;
+import org.briarproject.briar.api.blog.BlogSharingManager;
+import org.briarproject.briar.api.feed.FeedManager;
+import org.briarproject.briar.api.forum.ForumManager;
+import org.briarproject.briar.api.forum.ForumSharingManager;
+import org.briarproject.briar.api.introduction.IntroductionManager;
+import org.briarproject.briar.api.messaging.ConversationManager;
+import org.briarproject.briar.api.messaging.MessagingManager;
+import org.briarproject.briar.api.messaging.PrivateMessageFactory;
+import org.briarproject.briar.api.privategroup.GroupMessageFactory;
+import org.briarproject.briar.api.privategroup.PrivateGroupFactory;
+import org.briarproject.briar.api.privategroup.PrivateGroupManager;
+import org.briarproject.briar.api.privategroup.invitation.GroupInvitationFactory;
+import org.briarproject.briar.api.privategroup.invitation.GroupInvitationManager;
+
+import java.util.concurrent.Executor;
+
+import javax.inject.Singleton;
+
+import dagger.Component;
+
+@Singleton
+@Component(modules = {
+		BrambleCoreModule.class,
+		BriarCoreModule.class,
+		BrambleAndroidModule.class,
+		AppModule.class
+})
+public interface AndroidComponent
+		extends BrambleCoreEagerSingletons, BriarCoreEagerSingletons {
+
+	// Exposed objects
+	@CryptoExecutor
+	Executor cryptoExecutor();
+
+	PasswordStrengthEstimator passwordStrengthIndicator();
+
+	CryptoComponent cryptoComponent();
+
+	DatabaseConfig databaseConfig();
+
+	ReferenceManager referenceMangager();
+
+	@DatabaseExecutor
+	Executor databaseExecutor();
+
+	LifecycleManager lifecycleManager();
+
+	IdentityManager identityManager();
+
+	PluginManager pluginManager();
+
+	EventBus eventBus();
+
+	InvitationTaskFactory invitationTaskFactory();
+
+	AndroidNotificationManager androidNotificationManager();
+
+	ConnectionRegistry connectionRegistry();
+
+	ContactManager contactManager();
+
+	ConversationManager conversationManager();
+
+	MessagingManager messagingManager();
+
+	PrivateMessageFactory privateMessageFactory();
+
+	PrivateGroupManager privateGroupManager();
+
+	GroupInvitationFactory groupInvitationFactory();
+
+	GroupInvitationManager groupInvitationManager();
+
+	PrivateGroupFactory privateGroupFactory();
+
+	GroupMessageFactory groupMessageFactory();
+
+	ForumManager forumManager();
+
+	ForumSharingManager forumSharingManager();
+
+	BlogSharingManager blogSharingManager();
+
+	BlogManager blogManager();
+
+	BlogPostFactory blogPostFactory();
+
+	SettingsManager settingsManager();
+
+	ContactExchangeTask contactExchangeTask();
+
+	KeyAgreementTaskFactory keyAgreementTaskFactory();
+
+	PayloadEncoder payloadEncoder();
+
+	PayloadParser payloadParser();
+
+	IntroductionManager introductionManager();
+
+	AndroidExecutor androidExecutor();
+
+	FeedManager feedManager();
+
+	Clock clock();
+
+	@IoExecutor
+	Executor ioExecutor();
+
+	void inject(BriarService activity);
+
+	void inject(BriarReportSender briarReportSender);
+
+	// Eager singleton load
+	void inject(AppModule.EagerSingletons init);
+}

briar-android/src/main/java/org/briarproject/briar/android/AndroidEagerSingletons.java

@@ -0,0 +1,8 @@
+package org.briarproject.briar.android;
+
+class AndroidEagerSingletons {
+
+	static void initEagerSingletons(AndroidComponent c) {
+		c.inject(new AppModule.EagerSingletons());
+	}
+}

briar-android/src/main/java/org/briarproject/briar/android/AndroidNotificationManagerImpl.java

@@ -0,0 +1,867 @@
+package org.briarproject.briar.android;
+
+import android.app.Application;
+import android.app.NotificationManager;
+import android.app.PendingIntent;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.net.Uri;
+import android.os.Build;
+import android.support.annotation.UiThread;
+import android.support.v4.app.NotificationCompat;
+import android.support.v4.app.TaskStackBuilder;
+
+import org.briarproject.bramble.api.contact.ContactId;
+import org.briarproject.bramble.api.db.DatabaseExecutor;
+import org.briarproject.bramble.api.db.DbException;
+import org.briarproject.bramble.api.event.Event;
+import org.briarproject.bramble.api.event.EventListener;
+import org.briarproject.bramble.api.lifecycle.Service;
+import org.briarproject.bramble.api.lifecycle.ServiceException;
+import org.briarproject.bramble.api.nullsafety.MethodsNotNullByDefault;
+import org.briarproject.bramble.api.nullsafety.ParametersNotNullByDefault;
+import org.briarproject.bramble.api.settings.Settings;
+import org.briarproject.bramble.api.settings.SettingsManager;
+import org.briarproject.bramble.api.settings.event.SettingsUpdatedEvent;
+import org.briarproject.bramble.api.sync.GroupId;
+import org.briarproject.bramble.api.system.AndroidExecutor;
+import org.briarproject.bramble.util.StringUtils;
+import org.briarproject.briar.R;
+import org.briarproject.briar.android.contact.ConversationActivity;
+import org.briarproject.briar.android.forum.ForumActivity;
+import org.briarproject.briar.android.navdrawer.NavDrawerActivity;
+import org.briarproject.briar.android.privategroup.conversation.GroupActivity;
+import org.briarproject.briar.api.android.AndroidNotificationManager;
+import org.briarproject.briar.api.blog.event.BlogPostAddedEvent;
+import org.briarproject.briar.api.forum.event.ForumPostReceivedEvent;
+import org.briarproject.briar.api.introduction.event.IntroductionRequestReceivedEvent;
+import org.briarproject.briar.api.introduction.event.IntroductionResponseReceivedEvent;
+import org.briarproject.briar.api.introduction.event.IntroductionSucceededEvent;
+import org.briarproject.briar.api.messaging.event.PrivateMessageReceivedEvent;
+import org.briarproject.briar.api.privategroup.event.GroupMessageAddedEvent;
+import org.briarproject.briar.api.sharing.event.InvitationRequestReceivedEvent;
+import org.briarproject.briar.api.sharing.event.InvitationResponseReceivedEvent;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Executor;
+import java.util.concurrent.Future;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.logging.Logger;
+
+import javax.annotation.concurrent.ThreadSafe;
+import javax.inject.Inject;
+
+import static android.app.Notification.DEFAULT_LIGHTS;
+import static android.app.Notification.DEFAULT_SOUND;
+import static android.app.Notification.DEFAULT_VIBRATE;
+import static android.content.Context.NOTIFICATION_SERVICE;
+import static android.content.Intent.FLAG_ACTIVITY_CLEAR_TOP;
+import static android.content.Intent.FLAG_ACTIVITY_SINGLE_TOP;
+import static android.support.v4.app.NotificationCompat.CATEGORY_MESSAGE;
+import static android.support.v4.app.NotificationCompat.CATEGORY_SOCIAL;
+import static android.support.v4.app.NotificationCompat.VISIBILITY_SECRET;
+import static java.util.logging.Level.WARNING;
+import static org.briarproject.briar.android.activity.BriarActivity.GROUP_ID;
+import static org.briarproject.briar.android.contact.ConversationActivity.CONTACT_ID;
+import static org.briarproject.briar.android.navdrawer.NavDrawerActivity.INTENT_BLOGS;
+import static org.briarproject.briar.android.navdrawer.NavDrawerActivity.INTENT_CONTACTS;
+import static org.briarproject.briar.android.navdrawer.NavDrawerActivity.INTENT_FORUMS;
+import static org.briarproject.briar.android.navdrawer.NavDrawerActivity.INTENT_GROUPS;
+import static org.briarproject.briar.android.settings.SettingsFragment.PREF_NOTIFY_BLOG;
+import static org.briarproject.briar.android.settings.SettingsFragment.PREF_NOTIFY_GROUP;
+import static org.briarproject.briar.android.settings.SettingsFragment.SETTINGS_NAMESPACE;
+
+@ThreadSafe
+@MethodsNotNullByDefault
+@ParametersNotNullByDefault
+class AndroidNotificationManagerImpl implements AndroidNotificationManager,
+		Service, EventListener {
+
+	// Notification IDs
+	private static final int PRIVATE_MESSAGE_NOTIFICATION_ID = 3;
+	private static final int GROUP_MESSAGE_NOTIFICATION_ID = 4;
+	private static final int FORUM_POST_NOTIFICATION_ID = 5;
+	private static final int BLOG_POST_NOTIFICATION_ID = 6;
+	private static final int INTRODUCTION_SUCCESS_NOTIFICATION_ID = 7;
+
+	// Content URIs to differentiate between pending intents
+	private static final String CONTACT_URI =
+			"content://org.briarproject/contact";
+	private static final String GROUP_URI =
+			"content://org.briarproject/group";
+	private static final String FORUM_URI =
+			"content://org.briarproject/forum";
+	private static final String BLOG_URI =
+			"content://org.briarproject/blog";
+
+	// Actions for intents that are broadcast when notifications are dismissed
+	private static final String CLEAR_PRIVATE_MESSAGE_ACTION =
+			"org.briarproject.briar.CLEAR_PRIVATE_MESSAGE_NOTIFICATION";
+	private static final String CLEAR_GROUP_ACTION =
+			"org.briarproject.briar.CLEAR_GROUP_NOTIFICATION";
+	private static final String CLEAR_FORUM_ACTION =
+			"org.briarproject.briar.CLEAR_FORUM_NOTIFICATION";
+	private static final String CLEAR_BLOG_ACTION =
+			"org.briarproject.briar.CLEAR_BLOG_NOTIFICATION";
+	private static final String CLEAR_INTRODUCTION_ACTION =
+			"org.briarproject.briar.CLEAR_INTRODUCTION_NOTIFICATION";
+
+	private static final Logger LOG =
+			Logger.getLogger(AndroidNotificationManagerImpl.class.getName());
+
+	private final Executor dbExecutor;
+	private final SettingsManager settingsManager;
+	private final AndroidExecutor androidExecutor;
+	private final Context appContext;
+	private final BroadcastReceiver receiver = new DeleteIntentReceiver();
+	private final AtomicBoolean used = new AtomicBoolean(false);
+
+	// The following must only be accessed on the main UI thread
+	private final Map<ContactId, Integer> contactCounts = new HashMap<>();
+	private final Map<GroupId, Integer> groupCounts = new HashMap<>();
+	private final Map<GroupId, Integer> forumCounts = new HashMap<>();
+	private final Map<GroupId, Integer> blogCounts = new HashMap<>();
+	private int contactTotal = 0, groupTotal = 0, forumTotal = 0, blogTotal = 0;
+	private int introductionTotal = 0;
+	private int nextRequestId = 0;
+	private ContactId blockedContact = null;
+	private GroupId blockedGroup = null;
+	private boolean blockContacts = false, blockGroups = false;
+	private boolean blockForums = false, blockBlogs = false;
+	private boolean blockIntroductions = false;
+
+	private volatile Settings settings = new Settings();
+
+	@Inject
+	AndroidNotificationManagerImpl(@DatabaseExecutor Executor dbExecutor,
+			SettingsManager settingsManager, AndroidExecutor androidExecutor,
+			Application app) {
+		this.dbExecutor = dbExecutor;
+		this.settingsManager = settingsManager;
+		this.androidExecutor = androidExecutor;
+		appContext = app.getApplicationContext();
+	}
+
+	@Override
+	public void startService() throws ServiceException {
+		if (used.getAndSet(true)) throw new IllegalStateException();
+		// Load settings
+		try {
+			settings = settingsManager.getSettings(SETTINGS_NAMESPACE);
+		} catch (DbException e) {
+			throw new ServiceException(e);
+		}
+		// Register a broadcast receiver for notifications being dismissed
+		Future<Void> f = androidExecutor.runOnUiThread(new Callable<Void>() {
+			@Override
+			public Void call() {
+				IntentFilter filter = new IntentFilter();
+				filter.addAction(CLEAR_PRIVATE_MESSAGE_ACTION);
+				filter.addAction(CLEAR_GROUP_ACTION);
+				filter.addAction(CLEAR_FORUM_ACTION);
+				filter.addAction(CLEAR_BLOG_ACTION);
+				filter.addAction(CLEAR_INTRODUCTION_ACTION);
+				appContext.registerReceiver(receiver, filter);
+				return null;
+			}
+		});
+		try {
+			f.get();
+		} catch (InterruptedException | ExecutionException e) {
+			throw new ServiceException(e);
+		}
+	}
+
+	@Override
+	public void stopService() throws ServiceException {
+		// Clear all notifications and unregister the broadcast receiver
+		Future<Void> f = androidExecutor.runOnUiThread(new Callable<Void>() {
+			@Override
+			public Void call() {
+				clearContactNotification();
+				clearGroupMessageNotification();
+				clearForumPostNotification();
+				clearBlogPostNotification();
+				clearIntroductionSuccessNotification();
+				appContext.unregisterReceiver(receiver);
+				return null;
+			}
+		});
+		try {
+			f.get();
+		} catch (InterruptedException | ExecutionException e) {
+			throw new ServiceException(e);
+		}
+	}
+
+	@UiThread
+	private void clearContactNotification() {
+		contactCounts.clear();
+		contactTotal = 0;
+		Object o = appContext.getSystemService(NOTIFICATION_SERVICE);
+		NotificationManager nm = (NotificationManager) o;
+		nm.cancel(PRIVATE_MESSAGE_NOTIFICATION_ID);
+	}
+
+	@UiThread
+	private void clearGroupMessageNotification() {
+		groupCounts.clear();
+		groupTotal = 0;
+		Object o = appContext.getSystemService(NOTIFICATION_SERVICE);
+		NotificationManager nm = (NotificationManager) o;
+		nm.cancel(GROUP_MESSAGE_NOTIFICATION_ID);
+	}
+
+	@UiThread
+	private void clearForumPostNotification() {
+		forumCounts.clear();
+		forumTotal = 0;
+		Object o = appContext.getSystemService(NOTIFICATION_SERVICE);
+		NotificationManager nm = (NotificationManager) o;
+		nm.cancel(FORUM_POST_NOTIFICATION_ID);
+	}
+
+	@UiThread
+	private void clearBlogPostNotification() {
+		blogCounts.clear();
+		blogTotal = 0;
+		Object o = appContext.getSystemService(NOTIFICATION_SERVICE);
+		NotificationManager nm = (NotificationManager) o;
+		nm.cancel(BLOG_POST_NOTIFICATION_ID);
+	}
+
+	@UiThread
+	private void clearIntroductionSuccessNotification() {
+		introductionTotal = 0;
+		Object o = appContext.getSystemService(NOTIFICATION_SERVICE);
+		NotificationManager nm = (NotificationManager) o;
+		nm.cancel(INTRODUCTION_SUCCESS_NOTIFICATION_ID);
+	}
+
+	@Override
+	public void eventOccurred(Event e) {
+		if (e instanceof SettingsUpdatedEvent) {
+			SettingsUpdatedEvent s = (SettingsUpdatedEvent) e;
+			if (s.getNamespace().equals(SETTINGS_NAMESPACE)) loadSettings();
+		} else if (e instanceof PrivateMessageReceivedEvent) {
+			PrivateMessageReceivedEvent p = (PrivateMessageReceivedEvent) e;
+			showContactNotification(p.getContactId());
+		} else if (e instanceof GroupMessageAddedEvent) {
+			GroupMessageAddedEvent g = (GroupMessageAddedEvent) e;
+			if (!g.isLocal()) showGroupMessageNotification(g.getGroupId());
+		} else if (e instanceof ForumPostReceivedEvent) {
+			ForumPostReceivedEvent f = (ForumPostReceivedEvent) e;
+			showForumPostNotification(f.getGroupId());
+		} else if (e instanceof BlogPostAddedEvent) {
+			BlogPostAddedEvent b = (BlogPostAddedEvent) e;
+			showBlogPostNotification(b.getGroupId());
+		} else if (e instanceof IntroductionRequestReceivedEvent) {
+			ContactId c = ((IntroductionRequestReceivedEvent) e).getContactId();
+			showContactNotification(c);
+		} else if (e instanceof IntroductionResponseReceivedEvent) {
+			ContactId c =
+					((IntroductionResponseReceivedEvent) e).getContactId();
+			showContactNotification(c);
+		} else if (e instanceof InvitationRequestReceivedEvent) {
+			ContactId c = ((InvitationRequestReceivedEvent) e).getContactId();
+			showContactNotification(c);
+		} else if (e instanceof InvitationResponseReceivedEvent) {
+			ContactId c = ((InvitationResponseReceivedEvent) e).getContactId();
+			showContactNotification(c);
+		} else if (e instanceof IntroductionSucceededEvent) {
+			showIntroductionNotification();
+		}
+	}
+
+	private void loadSettings() {
+		dbExecutor.execute(new Runnable() {
+			@Override
+			public void run() {
+				try {
+					settings = settingsManager.getSettings(SETTINGS_NAMESPACE);
+				} catch (DbException e) {
+					if (LOG.isLoggable(WARNING))
+						LOG.log(WARNING, e.toString(), e);
+				}
+			}
+		});
+	}
+
+	private void showContactNotification(final ContactId c) {
+		androidExecutor.runOnUiThread(new Runnable() {
+			@Override
+			public void run() {
+				if (blockContacts) return;
+				if (c.equals(blockedContact)) return;
+				Integer count = contactCounts.get(c);
+				if (count == null) contactCounts.put(c, 1);
+				else contactCounts.put(c, count + 1);
+				contactTotal++;
+				updateContactNotification();
+			}
+		});
+	}
+
+	@Override
+	public void clearContactNotification(final ContactId c) {
+		androidExecutor.runOnUiThread(new Runnable() {
+			@Override
+			public void run() {
+				Integer count = contactCounts.remove(c);
+				if (count == null) return; // Already cleared
+				contactTotal -= count;
+				updateContactNotification();
+			}
+		});
+	}
+
+	@UiThread
+	private void updateContactNotification() {
+		if (contactTotal == 0) {
+			clearContactNotification();
+		} else if (settings.getBoolean("notifyPrivateMessages", true)) {
+			NotificationCompat.Builder b =
+					new NotificationCompat.Builder(appContext);
+			b.setSmallIcon(R.drawable.message_notification_icon);
+			b.setContentTitle(appContext.getText(R.string.app_name));
+			b.setContentText(appContext.getResources().getQuantityString(
+					R.plurals.private_message_notification_text, contactTotal,
+					contactTotal));
+			boolean sound = settings.getBoolean("notifySound", true);
+			String ringtoneUri = settings.get("notifyRingtoneUri");
+			if (sound && !StringUtils.isNullOrEmpty(ringtoneUri))
+				b.setSound(Uri.parse(ringtoneUri));
+			b.setDefaults(getDefaults());
+			b.setOnlyAlertOnce(true);
+			b.setAutoCancel(true);
+			// Clear the counters if the notification is dismissed
+			Intent clear = new Intent(CLEAR_PRIVATE_MESSAGE_ACTION);
+			PendingIntent delete = PendingIntent.getBroadcast(appContext, 0,
+					clear, 0);
+			b.setDeleteIntent(delete);
+			if (contactCounts.size() == 1) {
+				// Touching the notification shows the relevant conversation
+				Intent i = new Intent(appContext, ConversationActivity.class);
+				ContactId c = contactCounts.keySet().iterator().next();
+				i.putExtra(CONTACT_ID, c.getInt());
+				i.setData(Uri.parse(CONTACT_URI + "/" + c.getInt()));
+				i.setFlags(FLAG_ACTIVITY_CLEAR_TOP | FLAG_ACTIVITY_SINGLE_TOP);
+				TaskStackBuilder t = TaskStackBuilder.create(appContext);
+				t.addParentStack(ConversationActivity.class);
+				t.addNextIntent(i);
+				b.setContentIntent(t.getPendingIntent(nextRequestId++, 0));
+			} else {
+				// Touching the notification shows the contact list
+				Intent i = new Intent(appContext, NavDrawerActivity.class);
+				i.putExtra(INTENT_CONTACTS, true);
+				i.setFlags(FLAG_ACTIVITY_CLEAR_TOP | FLAG_ACTIVITY_SINGLE_TOP);
+				i.setData(Uri.parse(CONTACT_URI));
+				TaskStackBuilder t = TaskStackBuilder.create(appContext);
+				t.addParentStack(NavDrawerActivity.class);
+				t.addNextIntent(i);
+				b.setContentIntent(t.getPendingIntent(nextRequestId++, 0));
+			}
+			if (Build.VERSION.SDK_INT >= 21) {
+				b.setCategory(CATEGORY_MESSAGE);
+				b.setVisibility(VISIBILITY_SECRET);
+			}
+			Object o = appContext.getSystemService(NOTIFICATION_SERVICE);
+			NotificationManager nm = (NotificationManager) o;
+			nm.notify(PRIVATE_MESSAGE_NOTIFICATION_ID, b.build());
+		}
+	}
+
+	@UiThread
+	private int getDefaults() {
+		int defaults = DEFAULT_LIGHTS;
+		boolean sound = settings.getBoolean("notifySound", true);
+		String ringtoneUri = settings.get("notifyRingtoneUri");
+		if (sound && StringUtils.isNullOrEmpty(ringtoneUri))
+			defaults |= DEFAULT_SOUND;
+		if (settings.getBoolean("notifyVibration", true))
+			defaults |= DEFAULT_VIBRATE;
+		return defaults;
+	}
+
+	@Override
+	public void clearAllContactNotifications() {
+		androidExecutor.runOnUiThread(new Runnable() {
+			@Override
+			public void run() {
+				clearContactNotification();
+				clearIntroductionSuccessNotification();
+			}
+		});
+	}
+
+	@UiThread
+	private void showGroupMessageNotification(final GroupId g) {
+		androidExecutor.runOnUiThread(new Runnable() {
+			@Override
+			public void run() {
+				if (blockGroups) return;
+				if (g.equals(blockedGroup)) return;
+				Integer count = groupCounts.get(g);
+				if (count == null) groupCounts.put(g, 1);
+				else groupCounts.put(g, count + 1);
+				groupTotal++;
+				updateGroupMessageNotification();
+			}
+		});
+	}
+
+	@Override
+	public void clearGroupMessageNotification(final GroupId g) {
+		androidExecutor.runOnUiThread(new Runnable() {
+			@Override
+			public void run() {
+				Integer count = groupCounts.remove(g);
+				if (count == null) return; // Already cleared
+				groupTotal -= count;
+				updateGroupMessageNotification();
+			}
+		});
+	}
+
+	@UiThread
+	private void updateGroupMessageNotification() {
+		if (groupTotal == 0) {
+			clearGroupMessageNotification();
+		} else if (settings.getBoolean(PREF_NOTIFY_GROUP, true)) {
+			NotificationCompat.Builder b =
+					new NotificationCompat.Builder(appContext);
+			b.setSmallIcon(R.drawable.message_notification_icon);
+			b.setContentTitle(appContext.getText(R.string.app_name));
+			b.setContentText(appContext.getResources().getQuantityString(
+					R.plurals.group_message_notification_text, groupTotal,
+					groupTotal));
+			String ringtoneUri = settings.get("notifyRingtoneUri");
+			if (!StringUtils.isNullOrEmpty(ringtoneUri))
+				b.setSound(Uri.parse(ringtoneUri));
+			b.setDefaults(getDefaults());
+			b.setOnlyAlertOnce(true);
+			b.setAutoCancel(true);
+			// Clear the counters if the notification is dismissed
+			Intent clear = new Intent(CLEAR_GROUP_ACTION);
+			PendingIntent delete = PendingIntent.getBroadcast(appContext, 0,
+					clear, 0);
+			b.setDeleteIntent(delete);
+			if (groupCounts.size() == 1) {
+				// Touching the notification shows the relevant group
+				Intent i = new Intent(appContext, GroupActivity.class);
+				GroupId g = groupCounts.keySet().iterator().next();
+				i.putExtra(GROUP_ID, g.getBytes());
+				String idHex = StringUtils.toHexString(g.getBytes());
+				i.setData(Uri.parse(GROUP_URI + "/" + idHex));
+				i.setFlags(FLAG_ACTIVITY_CLEAR_TOP | FLAG_ACTIVITY_SINGLE_TOP);
+				TaskStackBuilder t = TaskStackBuilder.create(appContext);
+				t.addParentStack(GroupActivity.class);
+				t.addNextIntent(i);
+				b.setContentIntent(t.getPendingIntent(nextRequestId++, 0));
+			} else {
+				// Touching the notification shows the group list
+				Intent i = new Intent(appContext, NavDrawerActivity.class);
+				i.putExtra(INTENT_GROUPS, true);
+				i.setFlags(FLAG_ACTIVITY_CLEAR_TOP | FLAG_ACTIVITY_SINGLE_TOP);
+				i.setData(Uri.parse(GROUP_URI));
+				TaskStackBuilder t = TaskStackBuilder.create(appContext);
+				t.addParentStack(NavDrawerActivity.class);
+				t.addNextIntent(i);
+				b.setContentIntent(t.getPendingIntent(nextRequestId++, 0));
+			}
+			if (Build.VERSION.SDK_INT >= 21) {
+				b.setCategory(CATEGORY_SOCIAL);
+				b.setVisibility(VISIBILITY_SECRET);
+			}
+			Object o = appContext.getSystemService(NOTIFICATION_SERVICE);
+			NotificationManager nm = (NotificationManager) o;
+			nm.notify(GROUP_MESSAGE_NOTIFICATION_ID, b.build());
+		}
+	}
+
+	@Override
+	public void clearAllGroupMessageNotifications() {
+		androidExecutor.runOnUiThread(new Runnable() {
+			@Override
+			public void run() {
+				clearGroupMessageNotification();
+			}
+		});
+	}
+
+	@UiThread
+	private void showForumPostNotification(final GroupId g) {
+		androidExecutor.runOnUiThread(new Runnable() {
+			@Override
+			public void run() {
+				if (blockForums) return;
+				if (g.equals(blockedGroup)) return;
+				Integer count = forumCounts.get(g);
+				if (count == null) forumCounts.put(g, 1);
+				else forumCounts.put(g, count + 1);
+				forumTotal++;
+				updateForumPostNotification();
+			}
+		});
+	}
+
+	@Override
+	public void clearForumPostNotification(final GroupId g) {
+		androidExecutor.runOnUiThread(new Runnable() {
+			@Override
+			public void run() {
+				Integer count = forumCounts.remove(g);
+				if (count == null) return; // Already cleared
+				forumTotal -= count;
+				updateForumPostNotification();
+			}
+		});
+	}
+
+	@UiThread
+	private void updateForumPostNotification() {
+		if (forumTotal == 0) {
+			clearForumPostNotification();
+		} else if (settings.getBoolean("notifyForumPosts", true)) {
+			NotificationCompat.Builder b =
+					new NotificationCompat.Builder(appContext);
+			b.setSmallIcon(R.drawable.message_notification_icon);
+			b.setContentTitle(appContext.getText(R.string.app_name));
+			b.setContentText(appContext.getResources().getQuantityString(
+					R.plurals.forum_post_notification_text, forumTotal,
+					forumTotal));
+			String ringtoneUri = settings.get("notifyRingtoneUri");
+			if (!StringUtils.isNullOrEmpty(ringtoneUri))
+				b.setSound(Uri.parse(ringtoneUri));
+			b.setDefaults(getDefaults());
+			b.setOnlyAlertOnce(true);
+			b.setAutoCancel(true);
+			// Clear the counters if the notification is dismissed
+			Intent clear = new Intent(CLEAR_FORUM_ACTION);
+			PendingIntent delete = PendingIntent.getBroadcast(appContext, 0,
+					clear, 0);
+			b.setDeleteIntent(delete);
+			if (forumCounts.size() == 1) {
+				// Touching the notification shows the relevant forum
+				Intent i = new Intent(appContext, ForumActivity.class);
+				GroupId g = forumCounts.keySet().iterator().next();
+				i.putExtra(GROUP_ID, g.getBytes());
+				String idHex = StringUtils.toHexString(g.getBytes());
+				i.setData(Uri.parse(FORUM_URI + "/" + idHex));
+				i.setFlags(FLAG_ACTIVITY_CLEAR_TOP | FLAG_ACTIVITY_SINGLE_TOP);
+				TaskStackBuilder t = TaskStackBuilder.create(appContext);
+				t.addParentStack(ForumActivity.class);
+				t.addNextIntent(i);
+				b.setContentIntent(t.getPendingIntent(nextRequestId++, 0));
+			} else {
+				// Touching the notification shows the forum list
+				Intent i = new Intent(appContext, NavDrawerActivity.class);
+				i.putExtra(INTENT_FORUMS, true);
+				i.setFlags(FLAG_ACTIVITY_CLEAR_TOP | FLAG_ACTIVITY_SINGLE_TOP);
+				i.setData(Uri.parse(FORUM_URI));
+				TaskStackBuilder t = TaskStackBuilder.create(appContext);
+				t.addParentStack(NavDrawerActivity.class);
+				t.addNextIntent(i);
+				b.setContentIntent(t.getPendingIntent(nextRequestId++, 0));
+			}
+			if (Build.VERSION.SDK_INT >= 21) {
+				b.setCategory(CATEGORY_SOCIAL);
+				b.setVisibility(VISIBILITY_SECRET);
+			}
+			Object o = appContext.getSystemService(NOTIFICATION_SERVICE);
+			NotificationManager nm = (NotificationManager) o;
+			nm.notify(FORUM_POST_NOTIFICATION_ID, b.build());
+		}
+	}
+
+	@Override
+	public void clearAllForumPostNotifications() {
+		androidExecutor.runOnUiThread(new Runnable() {
+			@Override
+			public void run() {
+				clearForumPostNotification();
+			}
+		});
+	}
+
+	@UiThread
+	private void showBlogPostNotification(final GroupId g) {
+		androidExecutor.runOnUiThread(new Runnable() {
+			@Override
+			public void run() {
+				if (blockBlogs) return;
+				if (g.equals(blockedGroup)) return;
+				Integer count = blogCounts.get(g);
+				if (count == null) blogCounts.put(g, 1);
+				else blogCounts.put(g, count + 1);
+				blogTotal++;
+				updateBlogPostNotification();
+			}
+		});
+	}
+
+	@Override
+	public void clearBlogPostNotification(final GroupId g) {
+		androidExecutor.runOnUiThread(new Runnable() {
+			@Override
+			public void run() {
+				Integer count = blogCounts.remove(g);
+				if (count == null) return; // Already cleared
+				blogTotal -= count;
+				updateBlogPostNotification();
+			}
+		});
+	}
+
+	@UiThread
+	private void updateBlogPostNotification() {
+		if (blogTotal == 0) {
+			clearBlogPostNotification();
+		} else if (settings.getBoolean(PREF_NOTIFY_BLOG, true)) {
+			NotificationCompat.Builder b =
+					new NotificationCompat.Builder(appContext);
+			b.setSmallIcon(R.drawable.message_notification_icon);
+			b.setContentTitle(appContext.getText(R.string.app_name));
+			b.setContentText(appContext.getResources().getQuantityString(
+					R.plurals.blog_post_notification_text, blogTotal,
+					blogTotal));
+			String ringtoneUri = settings.get("notifyRingtoneUri");
+			if (!StringUtils.isNullOrEmpty(ringtoneUri))
+				b.setSound(Uri.parse(ringtoneUri));
+			b.setDefaults(getDefaults());
+			b.setOnlyAlertOnce(true);
+			b.setAutoCancel(true);
+			// Clear the counters if the notification is dismissed
+			Intent clear = new Intent(CLEAR_BLOG_ACTION);
+			PendingIntent delete = PendingIntent.getBroadcast(appContext, 0,
+					clear, 0);
+			b.setDeleteIntent(delete);
+			// Touching the notification shows the combined blog feed
+			Intent i = new Intent(appContext, NavDrawerActivity.class);
+			i.putExtra(INTENT_BLOGS, true);
+			i.setFlags(FLAG_ACTIVITY_CLEAR_TOP | FLAG_ACTIVITY_SINGLE_TOP);
+			i.setData(Uri.parse(BLOG_URI));
+			TaskStackBuilder t = TaskStackBuilder.create(appContext);
+			t.addParentStack(NavDrawerActivity.class);
+			t.addNextIntent(i);
+			b.setContentIntent(t.getPendingIntent(nextRequestId++, 0));
+			if (Build.VERSION.SDK_INT >= 21) {
+				b.setCategory(CATEGORY_SOCIAL);
+				b.setVisibility(VISIBILITY_SECRET);
+			}
+			Object o = appContext.getSystemService(NOTIFICATION_SERVICE);
+			NotificationManager nm = (NotificationManager) o;
+			nm.notify(BLOG_POST_NOTIFICATION_ID, b.build());
+		}
+	}
+
+	@Override
+	public void clearAllBlogPostNotifications() {
+		androidExecutor.runOnUiThread(new Runnable() {
+			@Override
+			public void run() {
+				clearBlogPostNotification();
+			}
+		});
+	}
+
+	private void showIntroductionNotification() {
+		androidExecutor.runOnUiThread(new Runnable() {
+			@Override
+			public void run() {
+				if (blockIntroductions) return;
+				introductionTotal++;
+				updateIntroductionNotification();
+			}
+		});
+	}
+
+	@UiThread
+	private void updateIntroductionNotification() {
+		NotificationCompat.Builder b =
+				new NotificationCompat.Builder(appContext);
+		b.setSmallIcon(R.drawable.introduction_notification);
+		b.setContentTitle(appContext.getText(R.string.app_name));
+		b.setContentText(appContext.getResources().getQuantityString(
+				R.plurals.introduction_notification_text, introductionTotal,
+				introductionTotal));
+		String ringtoneUri = settings.get("notifyRingtoneUri");
+		if (!StringUtils.isNullOrEmpty(ringtoneUri))
+			b.setSound(Uri.parse(ringtoneUri));
+		b.setDefaults(getDefaults());
+		b.setOnlyAlertOnce(true);
+		b.setAutoCancel(true);
+		// Clear the counter if the notification is dismissed
+		Intent clear = new Intent(CLEAR_INTRODUCTION_ACTION);
+		PendingIntent delete = PendingIntent.getBroadcast(appContext, 0,
+				clear, 0);
+		b.setDeleteIntent(delete);
+		// Touching the notification shows the contact list
+		Intent i = new Intent(appContext, NavDrawerActivity.class);
+		i.putExtra(INTENT_CONTACTS, true);
+		i.setFlags(FLAG_ACTIVITY_CLEAR_TOP | FLAG_ACTIVITY_SINGLE_TOP);
+		i.setData(Uri.parse(CONTACT_URI));
+		TaskStackBuilder t = TaskStackBuilder.create(appContext);
+		t.addParentStack(NavDrawerActivity.class);
+		t.addNextIntent(i);
+		b.setContentIntent(t.getPendingIntent(nextRequestId++, 0));
+		if (Build.VERSION.SDK_INT >= 21) {
+			b.setCategory(CATEGORY_MESSAGE);
+			b.setVisibility(VISIBILITY_SECRET);
+		}
+		Object o = appContext.getSystemService(NOTIFICATION_SERVICE);
+		NotificationManager nm = (NotificationManager) o;
+		nm.notify(INTRODUCTION_SUCCESS_NOTIFICATION_ID, b.build());
+	}
+
+	@Override
+	public void blockNotification(final GroupId g) {
+		androidExecutor.runOnUiThread(new Runnable() {
+			@Override
+			public void run() {
+				blockedGroup = g;
+			}
+		});
+	}
+
+	@Override
+	public void unblockNotification(final GroupId g) {
+		androidExecutor.runOnUiThread(new Runnable() {
+			@Override
+			public void run() {
+				if (g.equals(blockedGroup)) blockedGroup = null;
+			}
+		});
+	}
+
+	@Override
+	public void blockContactNotification(final ContactId c) {
+		androidExecutor.runOnUiThread(new Runnable() {
+			@Override
+			public void run() {
+				blockedContact = c;
+			}
+		});
+	}
+
+	@Override
+	public void unblockContactNotification(final ContactId c) {
+		androidExecutor.runOnUiThread(new Runnable() {
+			@Override
+			public void run() {
+				if (c.equals(blockedContact)) blockedContact = null;
+			}
+		});
+	}
+
+	@Override
+	public void blockAllContactNotifications() {
+		androidExecutor.runOnUiThread(new Runnable() {
+			@Override
+			public void run() {
+				blockContacts = true;
+				blockIntroductions = true;
+			}
+		});
+	}
+
+	@Override
+	public void unblockAllContactNotifications() {
+		androidExecutor.runOnUiThread(new Runnable() {
+			@Override
+			public void run() {
+				blockContacts = false;
+				blockIntroductions = false;
+			}
+		});
+	}
+
+	@Override
+	public void blockAllGroupMessageNotifications() {
+		androidExecutor.runOnUiThread(new Runnable() {
+			@Override
+			public void run() {
+				blockGroups = true;
+			}
+		});
+	}
+
+	@Override
+	public void unblockAllGroupMessageNotifications() {
+		androidExecutor.runOnUiThread(new Runnable() {
+			@Override
+			public void run() {
+				blockGroups = false;
+			}
+		});
+	}
+
+	@Override
+	public void blockAllForumPostNotifications() {
+		androidExecutor.runOnUiThread(new Runnable() {
+			@Override
+			public void run() {
+				blockForums = true;
+			}
+		});
+	}
+
+	@Override
+	public void unblockAllForumPostNotifications() {
+		androidExecutor.runOnUiThread(new Runnable() {
+			@Override
+			public void run() {
+				blockForums = false;
+			}
+		});
+	}
+
+	@Override
+	public void blockAllBlogPostNotifications() {
+		androidExecutor.runOnUiThread(new Runnable() {
+			@Override
+			public void run() {
+				blockBlogs = true;
+			}
+		});
+	}
+
+	@Override
+	public void unblockAllBlogPostNotifications() {
+		androidExecutor.runOnUiThread(new Runnable() {
+			@Override
+			public void run() {
+				blockBlogs = false;
+			}
+		});
+	}
+
+	private class DeleteIntentReceiver extends BroadcastReceiver {
+
+		@Override
+		public void onReceive(Context context, Intent intent) {
+			final String action = intent.getAction();
+			androidExecutor.runOnUiThread(new Runnable() {
+				@Override
+				public void run() {
+					if (CLEAR_PRIVATE_MESSAGE_ACTION.equals(action)) {
+						clearContactNotification();
+					} else if (CLEAR_GROUP_ACTION.equals(action)) {
+						clearGroupMessageNotification();
+					} else if (CLEAR_FORUM_ACTION.equals(action)) {
+						clearForumPostNotification();
+					} else if (CLEAR_BLOG_ACTION.equals(action)) {
+						clearBlogPostNotification();
+					} else if (CLEAR_INTRODUCTION_ACTION.equals(action)) {
+						clearIntroductionSuccessNotification();
+					}
+				}
+			});
+		}
+	}
+}

briar-android/src/main/java/org/briarproject/briar/android/AppModule.java

@@ -0,0 +1,169 @@
+package org.briarproject.briar.android;
+
+import android.app.Application;
+
+import org.briarproject.bramble.api.crypto.CryptoComponent;
+import org.briarproject.bramble.api.crypto.PublicKey;
+import org.briarproject.bramble.api.crypto.SecretKey;
+import org.briarproject.bramble.api.db.DatabaseConfig;
+import org.briarproject.bramble.api.event.EventBus;
+import org.briarproject.bramble.api.lifecycle.LifecycleManager;
+import org.briarproject.bramble.api.nullsafety.MethodsNotNullByDefault;
+import org.briarproject.bramble.api.nullsafety.NotNullByDefault;
+import org.briarproject.bramble.api.nullsafety.ParametersNotNullByDefault;
+import org.briarproject.bramble.api.reporting.DevConfig;
+import org.briarproject.bramble.api.ui.UiCallback;
+import org.briarproject.bramble.util.StringUtils;
+import org.briarproject.briar.api.android.AndroidNotificationManager;
+import org.briarproject.briar.api.android.ReferenceManager;
+
+import java.io.File;
+import java.security.GeneralSecurityException;
+
+import javax.annotation.Nullable;
+import javax.inject.Inject;
+import javax.inject.Singleton;
+
+import dagger.Module;
+import dagger.Provides;
+
+import static android.content.Context.MODE_PRIVATE;
+import static org.briarproject.bramble.api.reporting.ReportingConstants.DEV_ONION_ADDRESS;
+import static org.briarproject.bramble.api.reporting.ReportingConstants.DEV_PUBLIC_KEY_HEX;
+
+@Module
+public class AppModule {
+
+	static class EagerSingletons {
+		@Inject
+		AndroidNotificationManager androidNotificationManager;
+	}
+
+	private final Application application;
+	private final UiCallback uiCallback;
+
+	public AppModule(Application application) {
+		this.application = application;
+		uiCallback = new UiCallback() {
+
+			@Override
+			public int showChoice(String[] options, String... message) {
+				throw new UnsupportedOperationException();
+			}
+
+			@Override
+			public boolean showConfirmationMessage(String... message) {
+				throw new UnsupportedOperationException();
+			}
+
+			@Override
+			public void showMessage(String... message) {
+				throw new UnsupportedOperationException();
+			}
+		};
+	}
+
+	@Provides
+	@Singleton
+	Application providesApplication() {
+		return application;
+	}
+
+	@Provides
+	UiCallback provideUICallback() {
+		return uiCallback;
+	}
+
+	@Provides
+	@Singleton
+	DatabaseConfig provideDatabaseConfig(Application app) {
+		final File dir = app.getApplicationContext().getDir("db", MODE_PRIVATE);
+		@MethodsNotNullByDefault
+		@ParametersNotNullByDefault
+		DatabaseConfig databaseConfig = new DatabaseConfig() {
+
+			private volatile SecretKey key;
+			private volatile String nickname;
+
+			@Override
+			public boolean databaseExists() {
+				if (!dir.isDirectory()) return false;
+				File[] files = dir.listFiles();
+				return files != null && files.length > 0;
+			}
+
+			@Override
+			public File getDatabaseDirectory() {
+				return dir;
+			}
+
+			@Override
+			public void setEncryptionKey(SecretKey key) {
+				this.key = key;
+			}
+
+			@Override
+			public void setLocalAuthorName(String nickname) {
+				this.nickname = nickname;
+			}
+
+			@Override
+			@Nullable
+			public String getLocalAuthorName() {
+				return nickname;
+			}
+
+			@Override
+			@Nullable
+			public SecretKey getEncryptionKey() {
+				return key;
+			}
+
+			@Override
+			public long getMaxSize() {
+				return Long.MAX_VALUE;
+			}
+		};
+		return databaseConfig;
+	}
+
+	@Provides
+	@Singleton
+	DevConfig provideDevConfig(final CryptoComponent crypto) {
+		@NotNullByDefault
+		DevConfig devConfig = new DevConfig() {
+
+			@Override
+			public PublicKey getDevPublicKey() {
+				try {
+					return crypto.getMessageKeyParser().parsePublicKey(
+							StringUtils.fromHexString(DEV_PUBLIC_KEY_HEX));
+				} catch (GeneralSecurityException e) {
+					throw new RuntimeException(e);
+				}
+			}
+
+			@Override
+			public String getDevOnionAddress() {
+				return DEV_ONION_ADDRESS;
+			}
+		};
+		return devConfig;
+	}
+
+	@Provides
+	@Singleton
+	ReferenceManager provideReferenceManager() {
+		return new ReferenceManagerImpl();
+	}
+
+	@Provides
+	@Singleton
+	AndroidNotificationManager provideAndroidNotificationManager(
+			LifecycleManager lifecycleManager, EventBus eventBus,
+			AndroidNotificationManagerImpl notificationManager) {
+		lifecycleManager.registerService(notificationManager);
+		eventBus.addListener(notificationManager);
+		return notificationManager;
+	}
+}

briar-android/src/main/java/org/briarproject/briar/android/BriarApplication.java

@@ -0,0 +1,10 @@
+package org.briarproject.briar.android;
+
+/**
+ * This exists so that the Application object will not necessarily be cast
+ * directly to the Briar application object.
+ */
+public interface BriarApplication {
+
+	AndroidComponent getApplicationComponent();
+}

briar-android/src/main/java/org/briarproject/briar/android/BriarApplicationImpl.java

@@ -0,0 +1,92 @@
+package org.briarproject.briar.android;
+
+import android.app.Application;
+import android.content.Context;
+
+import org.acra.ACRA;
+import org.acra.ReportingInteractionMode;
+import org.acra.annotation.ReportsCrashes;
+import org.briarproject.bramble.BrambleCoreModule;
+import org.briarproject.briar.BriarCoreModule;
+import org.briarproject.briar.R;
+import org.briarproject.briar.android.reporting.BriarReportPrimer;
+import org.briarproject.briar.android.reporting.BriarReportSenderFactory;
+import org.briarproject.briar.android.reporting.DevReportActivity;
+
+import java.util.logging.Logger;
+
+import static org.acra.ReportField.ANDROID_VERSION;
+import static org.acra.ReportField.APP_VERSION_CODE;
+import static org.acra.ReportField.APP_VERSION_NAME;
+import static org.acra.ReportField.BRAND;
+import static org.acra.ReportField.BUILD_CONFIG;
+import static org.acra.ReportField.CRASH_CONFIGURATION;
+import static org.acra.ReportField.CUSTOM_DATA;
+import static org.acra.ReportField.DEVICE_FEATURES;
+import static org.acra.ReportField.DISPLAY;
+import static org.acra.ReportField.INITIAL_CONFIGURATION;
+import static org.acra.ReportField.LOGCAT;
+import static org.acra.ReportField.PACKAGE_NAME;
+import static org.acra.ReportField.PHONE_MODEL;
+import static org.acra.ReportField.PRODUCT;
+import static org.acra.ReportField.REPORT_ID;
+import static org.acra.ReportField.STACK_TRACE;
+import static org.acra.ReportField.USER_APP_START_DATE;
+import static org.acra.ReportField.USER_CRASH_DATE;
+
+@ReportsCrashes(
+		reportPrimerClass = BriarReportPrimer.class,
+		logcatArguments = {"-d", "-v", "time", "*:I"},
+		reportSenderFactoryClasses = {BriarReportSenderFactory.class},
+		mode = ReportingInteractionMode.DIALOG,
+		reportDialogClass = DevReportActivity.class,
+		resDialogOkToast = R.string.dev_report_saved,
+		deleteOldUnsentReportsOnApplicationStart = false,
+		customReportContent = {
+				REPORT_ID,
+				APP_VERSION_CODE, APP_VERSION_NAME, PACKAGE_NAME,
+				PHONE_MODEL, ANDROID_VERSION, BRAND, PRODUCT,
+				BUILD_CONFIG,
+				CUSTOM_DATA,
+				STACK_TRACE,
+				INITIAL_CONFIGURATION, CRASH_CONFIGURATION,
+				DISPLAY, DEVICE_FEATURES,
+				USER_APP_START_DATE, USER_CRASH_DATE,
+				LOGCAT
+		}
+)
+public class BriarApplicationImpl extends Application
+		implements BriarApplication {
+
+	private static final Logger LOG =
+			Logger.getLogger(BriarApplicationImpl.class.getName());
+
+	private AndroidComponent applicationComponent;
+
+	@Override
+	protected void attachBaseContext(Context base) {
+		super.attachBaseContext(base);
+		ACRA.init(this);
+	}
+
+	@Override
+	public void onCreate() {
+		super.onCreate();
+		LOG.info("Created");
+
+		applicationComponent = DaggerAndroidComponent.builder()
+				.appModule(new AppModule(this))
+				.build();
+
+		// We need to load the eager singletons directly after making the
+		// dependency graphs
+		BrambleCoreModule.initEagerSingletons(applicationComponent);
+		BriarCoreModule.initEagerSingletons(applicationComponent);
+		AndroidEagerSingletons.initEagerSingletons(applicationComponent);
+	}
+
+	@Override
+	public AndroidComponent getApplicationComponent() {
+		return applicationComponent;
+	}
+}

briar-android/src/main/java/org/briarproject/briar/android/BriarService.java

@@ -0,0 +1,231 @@
+package org.briarproject.briar.android;
+
+import android.app.NotificationManager;
+import android.app.PendingIntent;
+import android.app.Service;
+import android.content.ComponentName;
+import android.content.Intent;
+import android.content.ServiceConnection;
+import android.os.Binder;
+import android.os.Build;
+import android.os.IBinder;
+import android.support.v4.app.NotificationCompat;
+
+import org.briarproject.bramble.api.db.DatabaseConfig;
+import org.briarproject.bramble.api.lifecycle.LifecycleManager;
+import org.briarproject.bramble.api.lifecycle.LifecycleManager.StartResult;
+import org.briarproject.bramble.api.system.AndroidExecutor;
+import org.briarproject.briar.R;
+import org.briarproject.briar.android.navdrawer.NavDrawerActivity;
+
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.logging.Logger;
+
+import javax.inject.Inject;
+
+import static android.app.PendingIntent.FLAG_UPDATE_CURRENT;
+import static android.content.Intent.FLAG_ACTIVITY_CLEAR_TOP;
+import static android.content.Intent.FLAG_ACTIVITY_NEW_TASK;
+import static android.content.Intent.FLAG_ACTIVITY_SINGLE_TOP;
+import static android.support.v4.app.NotificationCompat.CATEGORY_SERVICE;
+import static android.support.v4.app.NotificationCompat.PRIORITY_MIN;
+import static android.support.v4.app.NotificationCompat.VISIBILITY_SECRET;
+import static java.util.logging.Level.WARNING;
+import static org.briarproject.bramble.api.lifecycle.LifecycleManager.StartResult.ALREADY_RUNNING;
+import static org.briarproject.bramble.api.lifecycle.LifecycleManager.StartResult.SUCCESS;
+
+public class BriarService extends Service {
+
+	private static final int ONGOING_NOTIFICATION_ID = 1;
+	private static final int FAILURE_NOTIFICATION_ID = 2;
+
+	private static final Logger LOG =
+			Logger.getLogger(BriarService.class.getName());
+
+	private final AtomicBoolean created = new AtomicBoolean(false);
+	private final Binder binder = new BriarBinder();
+
+	@Inject
+	protected DatabaseConfig databaseConfig;
+	// Fields that are accessed from background threads must be volatile
+	@Inject
+	protected volatile LifecycleManager lifecycleManager;
+	@Inject
+	protected volatile AndroidExecutor androidExecutor;
+	private volatile boolean started = false;
+
+	@Override
+	public void onCreate() {
+		super.onCreate();
+
+		BriarApplication application = (BriarApplication) getApplication();
+		application.getApplicationComponent().inject(this);
+
+		LOG.info("Created");
+		if (created.getAndSet(true)) {
+			LOG.info("Already created");
+			stopSelf();
+			return;
+		}
+		if (databaseConfig.getEncryptionKey() == null) {
+			LOG.info("No database key");
+			stopSelf();
+			return;
+		}
+		// Show an ongoing notification that the service is running
+		NotificationCompat.Builder b = new NotificationCompat.Builder(this);
+		b.setSmallIcon(R.drawable.ongoing_notification_icon);
+		b.setContentTitle(getText(R.string.ongoing_notification_title));
+		b.setContentText(getText(R.string.ongoing_notification_text));
+		b.setWhen(0); // Don't show the time
+		b.setOngoing(true);
+		Intent i = new Intent(this, NavDrawerActivity.class);
+		i.setFlags(FLAG_ACTIVITY_NEW_TASK | FLAG_ACTIVITY_CLEAR_TOP |
+				FLAG_ACTIVITY_SINGLE_TOP);
+		b.setContentIntent(PendingIntent.getActivity(this, 0, i, 0));
+		if (Build.VERSION.SDK_INT >= 21) {
+			b.setCategory(CATEGORY_SERVICE);
+			b.setVisibility(VISIBILITY_SECRET);
+		}
+		b.setPriority(PRIORITY_MIN);
+		startForeground(ONGOING_NOTIFICATION_ID, b.build());
+		// Start the services in a background thread
+		new Thread() {
+			@Override
+			public void run() {
+				String nickname = databaseConfig.getLocalAuthorName();
+				StartResult result = lifecycleManager.startServices(nickname);
+				if (result == SUCCESS) {
+					started = true;
+				} else if (result == ALREADY_RUNNING) {
+					LOG.info("Already running");
+					stopSelf();
+				} else {
+					if (LOG.isLoggable(WARNING))
+						LOG.warning("Startup failed: " + result);
+					showStartupFailureNotification(result);
+					stopSelf();
+				}
+			}
+		}.start();
+	}
+
+	private void showStartupFailureNotification(final StartResult result) {
+		androidExecutor.runOnUiThread(new Runnable() {
+			@Override
+			public void run() {
+				NotificationCompat.Builder b =
+						new NotificationCompat.Builder(BriarService.this);
+				b.setSmallIcon(android.R.drawable.stat_notify_error);
+				b.setContentTitle(getText(
+						R.string.startup_failed_notification_title));
+				b.setContentText(getText(
+						R.string.startup_failed_notification_text));
+				Intent i = new Intent(BriarService.this,
+						StartupFailureActivity.class);
+				i.setFlags(FLAG_ACTIVITY_NEW_TASK);
+				i.putExtra("briar.START_RESULT", result);
+				i.putExtra("briar.FAILURE_NOTIFICATION_ID",
+						FAILURE_NOTIFICATION_ID);
+				b.setContentIntent(PendingIntent.getActivity(BriarService.this,
+						0, i, FLAG_UPDATE_CURRENT));
+				Object o = getSystemService(NOTIFICATION_SERVICE);
+				NotificationManager nm = (NotificationManager) o;
+				nm.notify(FAILURE_NOTIFICATION_ID, b.build());
+				// Bring the dashboard to the front to clear the back stack
+				i = new Intent(BriarService.this, NavDrawerActivity.class);
+				i.setFlags(FLAG_ACTIVITY_NEW_TASK | FLAG_ACTIVITY_CLEAR_TOP);
+				i.putExtra("briar.STARTUP_FAILED", true);
+				startActivity(i);
+			}
+		});
+	}
+
+	@Override
+	public int onStartCommand(Intent intent, int flags, int startId) {
+		return START_NOT_STICKY; // Don't restart automatically if killed
+	}
+
+	@Override
+	public IBinder onBind(Intent intent) {
+		return binder;
+	}
+
+	@Override
+	public void onDestroy() {
+		super.onDestroy();
+		LOG.info("Destroyed");
+		stopForeground(true);
+		// Stop the services in a background thread
+		new Thread() {
+			@Override
+			public void run() {
+				if (started) lifecycleManager.stopServices();
+			}
+		}.start();
+	}
+
+	@Override
+	public void onLowMemory() {
+		super.onLowMemory();
+		LOG.warning("Memory is low");
+		// FIXME: Work out what to do about it
+	}
+
+	/**
+	 * Waits for all services to start before returning.
+	 */
+	public void waitForStartup() throws InterruptedException {
+		lifecycleManager.waitForStartup();
+	}
+
+	/**
+	 * Waits for all services to stop before returning.
+	 */
+	public void waitForShutdown() throws InterruptedException {
+		lifecycleManager.waitForShutdown();
+	}
+
+	/**
+	 * Starts the shutdown process.
+	 */
+	public void shutdown() {
+		stopSelf(); // This will call onDestroy()
+	}
+
+	public class BriarBinder extends Binder {
+
+		/**
+		 * Returns the bound service.
+		 */
+		public BriarService getService() {
+			return BriarService.this;
+		}
+	}
+
+	public static class BriarServiceConnection implements ServiceConnection {
+
+		private final CountDownLatch binderLatch = new CountDownLatch(1);
+
+		private volatile IBinder binder = null;
+
+		@Override
+		public void onServiceConnected(ComponentName name, IBinder binder) {
+			this.binder = binder;
+			binderLatch.countDown();
+		}
+
+		@Override
+		public void onServiceDisconnected(ComponentName name) {
+		}
+
+		/**
+		 * Waits for the service to connect and returns its binder.
+		 */
+		public IBinder waitForBinder() throws InterruptedException {
+			binderLatch.await();
+			return binder;
+		}
+	}
+}

briar-android/src/main/java/org/briarproject/briar/android/DestroyableContext.java

@@ -0,0 +1,6 @@
+package org.briarproject.briar.android;
+
+public interface DestroyableContext {
+
+	void runOnUiThreadUnlessDestroyed(Runnable runnable);
+}

briar-android/src/main/java/org/briarproject/briar/android/ReferenceManagerImpl.java

@@ -0,0 +1,83 @@
+package org.briarproject.briar.android;
+
+import org.briarproject.briar.api.android.ReferenceManager;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
+import java.util.logging.Logger;
+
+import static java.util.logging.Level.INFO;
+
+class ReferenceManagerImpl implements ReferenceManager {
+
+	private static final Logger LOG =
+			Logger.getLogger(ReferenceManagerImpl.class.getName());
+
+	private final Lock lock = new ReentrantLock();
+
+	// The following are locking: lock
+	private final Map<Class<?>, Map<Long, Object>> outerMap = new HashMap<>();
+	private long nextHandle = 0;
+
+	@Override
+	public <T> T getReference(long handle, Class<T> c) {
+		lock.lock();
+		try {
+			Map<Long, Object> innerMap = outerMap.get(c);
+			if (innerMap == null) {
+				if (LOG.isLoggable(INFO))
+					LOG.info("0 handles for " + c.getName());
+				return null;
+			}
+			if (LOG.isLoggable(INFO))
+				LOG.info(innerMap.size() + " handles for " + c.getName());
+			Object o = innerMap.get(handle);
+			return c.cast(o);
+		} finally {
+			lock.unlock();
+		}
+
+	}
+
+	@Override
+	public <T> long putReference(T reference, Class<T> c) {
+		lock.lock();
+		try {
+			Map<Long, Object> innerMap = outerMap.get(c);
+			if (innerMap == null) {
+				innerMap = new HashMap<>();
+				outerMap.put(c, innerMap);
+			}
+			long handle = nextHandle++;
+			innerMap.put(handle, reference);
+			if (LOG.isLoggable(INFO)) {
+				LOG.info(innerMap.size() + " handles for " + c.getName() +
+						" after put");
+			}
+			return handle;
+		} finally {
+			lock.unlock();
+		}
+	}
+
+	@Override
+	public <T> T removeReference(long handle, Class<T> c) {
+		lock.lock();
+		try {
+			Map<Long, Object> innerMap = outerMap.get(c);
+			if (innerMap == null) return null;
+			Object o = innerMap.remove(handle);
+			if (innerMap.isEmpty()) outerMap.remove(c);
+			if (LOG.isLoggable(INFO)) {
+				LOG.info(innerMap.size() + " handles for " + c.getName() +
+						" after remove");
+			}
+			return c.cast(o);
+		} finally {
+			lock.unlock();
+		}
+
+	}
+}

briar-android/src/main/java/org/briarproject/briar/android/StartupFailureActivity.java

@@ -0,0 +1,49 @@
+package org.briarproject.briar.android;
+
+import android.app.NotificationManager;
+import android.content.Intent;
+import android.os.Bundle;
+import android.widget.TextView;
+
+import org.briarproject.briar.R;
+import org.briarproject.briar.android.activity.ActivityComponent;
+import org.briarproject.briar.android.activity.BaseActivity;
+
+import static org.briarproject.bramble.api.lifecycle.LifecycleManager.StartResult;
+
+public class StartupFailureActivity extends BaseActivity {
+
+	@Override
+	public void onCreate(Bundle state) {
+		super.onCreate(state);
+
+		setContentView(R.layout.activity_startup_failure);
+		handleIntent(getIntent());
+	}
+
+	@Override
+	public void injectActivity(ActivityComponent component) {
+
+	}
+
+	private void handleIntent(Intent i) {
+		StartResult result = (StartResult) i.getSerializableExtra("briar.START_RESULT");
+		int notificationId = i.getIntExtra("briar.FAILURE_NOTIFICATION_ID", -1);
+
+		// cancel notification
+		if (notificationId > -1) {
+			Object o = getSystemService(NOTIFICATION_SERVICE);
+			NotificationManager nm = (NotificationManager) o;
+			nm.cancel(notificationId);
+		}
+
+		// show proper error message
+		TextView view = (TextView) findViewById(R.id.errorView);
+		if (result.equals(StartResult.DB_ERROR)) {
+			view.setText(getText(R.string.startup_failed_db_error));
+		} else if (result.equals(StartResult.SERVICE_ERROR)) {
+			view.setText(getText(R.string.startup_failed_service_error));
+		}
+	}
+
+}

briar-android/src/main/java/org/briarproject/briar/android/TestingConstants.java

@@ -0,0 +1,26 @@
+package org.briarproject.briar.android;
+
+import java.util.logging.Level;
+
+import static java.util.logging.Level.INFO;
+import static java.util.logging.Level.OFF;
+
+public interface TestingConstants {
+
+	/**
+	 * Whether this is an alpha or beta build. This should be set to false for
+	 * release builds.
+	 */
+	boolean TESTING = true;
+
+	/** Default log level. */
+	Level DEFAULT_LOG_LEVEL = TESTING ? INFO : OFF;
+
+	/**
+	 * Whether to prevent screenshots from being taken. Setting this to true
+	 * prevents Recent Apps from storing screenshots of private information.
+	 * Unfortunately this also prevents the user from taking screenshots
+	 * intentionally.
+	 */
+	boolean PREVENT_SCREENSHOTS = !TESTING;
+}

briar-android/src/main/java/org/briarproject/briar/android/activity/ActivityComponent.java

@@ -0,0 +1,191 @@
+package org.briarproject.briar.android.activity;
+
+import android.app.Activity;
+
+import org.briarproject.briar.android.AndroidComponent;
+import org.briarproject.briar.android.blog.BlogActivity;
+import org.briarproject.briar.android.blog.BlogFragment;
+import org.briarproject.briar.android.blog.BlogModule;
+import org.briarproject.briar.android.blog.BlogPostFragment;
+import org.briarproject.briar.android.blog.FeedFragment;
+import org.briarproject.briar.android.blog.FeedPostFragment;
+import org.briarproject.briar.android.blog.ReblogActivity;
+import org.briarproject.briar.android.blog.ReblogFragment;
+import org.briarproject.briar.android.blog.RssFeedImportActivity;
+import org.briarproject.briar.android.blog.RssFeedManageActivity;
+import org.briarproject.briar.android.blog.WriteBlogPostActivity;
+import org.briarproject.briar.android.contact.ContactListFragment;
+import org.briarproject.briar.android.contact.ContactModule;
+import org.briarproject.briar.android.contact.ConversationActivity;
+import org.briarproject.briar.android.forum.CreateForumActivity;
+import org.briarproject.briar.android.forum.ForumActivity;
+import org.briarproject.briar.android.forum.ForumListFragment;
+import org.briarproject.briar.android.forum.ForumModule;
+import org.briarproject.briar.android.introduction.ContactChooserFragment;
+import org.briarproject.briar.android.introduction.IntroductionActivity;
+import org.briarproject.briar.android.introduction.IntroductionMessageFragment;
+import org.briarproject.briar.android.invitation.AddContactActivity;
+import org.briarproject.briar.android.keyagreement.IntroFragment;
+import org.briarproject.briar.android.keyagreement.KeyAgreementActivity;
+import org.briarproject.briar.android.keyagreement.ShowQrCodeFragment;
+import org.briarproject.briar.android.login.ChangePasswordActivity;
+import org.briarproject.briar.android.login.PasswordActivity;
+import org.briarproject.briar.android.login.SetupActivity;
+import org.briarproject.briar.android.navdrawer.NavDrawerActivity;
+import org.briarproject.briar.android.panic.PanicPreferencesActivity;
+import org.briarproject.briar.android.panic.PanicResponderActivity;
+import org.briarproject.briar.android.privategroup.conversation.GroupActivity;
+import org.briarproject.briar.android.privategroup.conversation.GroupConversationModule;
+import org.briarproject.briar.android.privategroup.creation.CreateGroupActivity;
+import org.briarproject.briar.android.privategroup.creation.CreateGroupFragment;
+import org.briarproject.briar.android.privategroup.creation.CreateGroupMessageFragment;
+import org.briarproject.briar.android.privategroup.creation.GroupCreateModule;
+import org.briarproject.briar.android.privategroup.creation.GroupInviteActivity;
+import org.briarproject.briar.android.privategroup.creation.GroupInviteFragment;
+import org.briarproject.briar.android.privategroup.invitation.GroupInvitationActivity;
+import org.briarproject.briar.android.privategroup.invitation.GroupInvitationModule;
+import org.briarproject.briar.android.privategroup.list.GroupListFragment;
+import org.briarproject.briar.android.privategroup.list.GroupListModule;
+import org.briarproject.briar.android.privategroup.memberlist.GroupMemberListActivity;
+import org.briarproject.briar.android.privategroup.memberlist.GroupMemberModule;
+import org.briarproject.briar.android.privategroup.reveal.GroupRevealModule;
+import org.briarproject.briar.android.privategroup.reveal.RevealContactsActivity;
+import org.briarproject.briar.android.privategroup.reveal.RevealContactsFragment;
+import org.briarproject.briar.android.settings.SettingsActivity;
+import org.briarproject.briar.android.sharing.BlogInvitationActivity;
+import org.briarproject.briar.android.sharing.BlogSharingStatusActivity;
+import org.briarproject.briar.android.sharing.ForumInvitationActivity;
+import org.briarproject.briar.android.sharing.ForumSharingStatusActivity;
+import org.briarproject.briar.android.sharing.ShareBlogActivity;
+import org.briarproject.briar.android.sharing.ShareBlogFragment;
+import org.briarproject.briar.android.sharing.ShareBlogMessageFragment;
+import org.briarproject.briar.android.sharing.ShareForumActivity;
+import org.briarproject.briar.android.sharing.ShareForumFragment;
+import org.briarproject.briar.android.sharing.ShareForumMessageFragment;
+import org.briarproject.briar.android.sharing.SharingModule;
+import org.briarproject.briar.android.splash.SplashScreenActivity;
+import org.thoughtcrime.securesms.components.emoji.EmojiProvider;
+import org.thoughtcrime.securesms.components.emoji.RecentEmojiPageModel;
+
+import dagger.Component;
+
+@ActivityScope
+@Component(
+		modules = {ActivityModule.class, ForumModule.class, SharingModule.class,
+				BlogModule.class, ContactModule.class, GroupListModule.class,
+				GroupCreateModule.class, GroupInvitationModule.class,
+				GroupConversationModule.class, GroupMemberModule.class,
+				GroupRevealModule.class},
+		dependencies = AndroidComponent.class)
+public interface ActivityComponent {
+
+	Activity activity();
+
+	void inject(SplashScreenActivity activity);
+
+	void inject(SetupActivity activity);
+
+	void inject(NavDrawerActivity activity);
+
+	void inject(PasswordActivity activity);
+
+	void inject(PanicResponderActivity activity);
+
+	void inject(PanicPreferencesActivity activity);
+
+	void inject(AddContactActivity activity);
+
+	void inject(KeyAgreementActivity activity);
+
+	void inject(ConversationActivity activity);
+
+	void inject(ForumInvitationActivity activity);
+
+	void inject(BlogInvitationActivity activity);
+
+	void inject(CreateGroupActivity activity);
+
+	void inject(GroupActivity activity);
+
+	void inject(GroupInviteActivity activity);
+
+	void inject(GroupInvitationActivity activity);
+
+	void inject(GroupMemberListActivity activity);
+
+	void inject(RevealContactsActivity activity);
+
+	void inject(CreateForumActivity activity);
+
+	void inject(ShareForumActivity activity);
+
+	void inject(ShareBlogActivity activity);
+
+	void inject(ForumSharingStatusActivity activity);
+
+	void inject(BlogSharingStatusActivity activity);
+
+	void inject(ForumActivity activity);
+
+	void inject(BlogActivity activity);
+
+	void inject(WriteBlogPostActivity activity);
+
+	void inject(BlogFragment fragment);
+
+	void inject(BlogPostFragment fragment);
+
+	void inject(FeedPostFragment fragment);
+
+	void inject(ReblogFragment fragment);
+
+	void inject(ReblogActivity activity);
+
+	void inject(SettingsActivity activity);
+
+	void inject(ChangePasswordActivity activity);
+
+	void inject(IntroductionActivity activity);
+
+	void inject(RssFeedImportActivity activity);
+
+	void inject(RssFeedManageActivity activity);
+
+	void inject(EmojiProvider emojiProvider);
+
+	void inject(RecentEmojiPageModel recentEmojiPageModel);
+
+	// Fragments
+	void inject(ContactListFragment fragment);
+
+	void inject(CreateGroupFragment fragment);
+
+	void inject(CreateGroupMessageFragment fragment);
+
+	void inject(GroupListFragment fragment);
+
+	void inject(GroupInviteFragment fragment);
+
+	void inject(RevealContactsFragment activity);
+
+	void inject(ForumListFragment fragment);
+
+	void inject(FeedFragment fragment);
+
+	void inject(IntroFragment fragment);
+
+	void inject(ShowQrCodeFragment fragment);
+
+	void inject(ContactChooserFragment fragment);
+
+	void inject(ShareForumFragment fragment);
+
+	void inject(ShareForumMessageFragment fragment);
+
+	void inject(ShareBlogFragment fragment);
+
+	void inject(ShareBlogMessageFragment fragment);
+
+	void inject(IntroductionMessageFragment fragment);
+
+}

briar-android/src/main/java/org/briarproject/briar/android/activity/ActivityModule.java

@@ -0,0 +1,101 @@
+package org.briarproject.briar.android.activity;
+
+import android.app.Activity;
+import android.content.SharedPreferences;
+
+import org.briarproject.briar.android.controller.BriarController;
+import org.briarproject.briar.android.controller.BriarControllerImpl;
+import org.briarproject.briar.android.controller.ConfigController;
+import org.briarproject.briar.android.controller.ConfigControllerImpl;
+import org.briarproject.briar.android.controller.DbController;
+import org.briarproject.briar.android.controller.DbControllerImpl;
+import org.briarproject.briar.android.login.PasswordController;
+import org.briarproject.briar.android.login.PasswordControllerImpl;
+import org.briarproject.briar.android.login.SetupController;
+import org.briarproject.briar.android.login.SetupControllerImpl;
+import org.briarproject.briar.android.navdrawer.NavDrawerController;
+import org.briarproject.briar.android.navdrawer.NavDrawerControllerImpl;
+
+import dagger.Module;
+import dagger.Provides;
+
+import static android.content.Context.MODE_PRIVATE;
+import static org.briarproject.briar.android.BriarService.BriarServiceConnection;
+
+@Module
+public class ActivityModule {
+
+	private final BaseActivity activity;
+
+	public ActivityModule(BaseActivity activity) {
+		this.activity = activity;
+	}
+
+	@ActivityScope
+	@Provides
+	BaseActivity provideBaseActivity() {
+		return activity;
+	}
+
+	@ActivityScope
+	@Provides
+	Activity provideActivity() {
+		return activity;
+	}
+
+	@ActivityScope
+	@Provides
+	SetupController provideSetupController(
+			SetupControllerImpl setupController) {
+		return setupController;
+	}
+
+	@ActivityScope
+	@Provides
+	ConfigController provideConfigController(
+			ConfigControllerImpl configController) {
+		return configController;
+	}
+
+	@ActivityScope
+	@Provides
+	SharedPreferences provideSharedPreferences(Activity activity) {
+		return activity.getSharedPreferences("db", MODE_PRIVATE);
+	}
+
+	@ActivityScope
+	@Provides
+	PasswordController providePasswordController(
+			PasswordControllerImpl passwordController) {
+		return passwordController;
+	}
+
+	@ActivityScope
+	@Provides
+	protected BriarController provideBriarController(
+			BriarControllerImpl briarController) {
+		activity.addLifecycleController(briarController);
+		return briarController;
+	}
+
+	@ActivityScope
+	@Provides
+	DbController provideDBController(DbControllerImpl dbController) {
+		return dbController;
+	}
+
+	@ActivityScope
+	@Provides
+	NavDrawerController provideNavDrawerController(
+			NavDrawerControllerImpl navDrawerController) {
+		activity.addLifecycleController(navDrawerController);
+		return navDrawerController;
+	}
+
+	@ActivityScope
+	@Provides
+	BriarServiceConnection provideBriarServiceConnection() {
+		return new BriarServiceConnection();
+	}
+
+}

briar-android/src/main/java/org/briarproject/briar/android/activity/ActivityScope.java

@@ -0,0 +1,11 @@
+package org.briarproject.briar.android.activity;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+import javax.inject.Scope;
+
+@Scope
+@Retention(RetentionPolicy.RUNTIME)
+public @interface ActivityScope {
+}

briar-android/src/main/java/org/briarproject/briar/android/activity/BaseActivity.java

@@ -0,0 +1,119 @@
+package org.briarproject.briar.android.activity;
+
+import android.os.Bundle;
+import android.os.IBinder;
+import android.support.v7.app.AppCompatActivity;
+import android.view.View;
+import android.view.inputmethod.InputMethodManager;
+
+import org.briarproject.briar.android.AndroidComponent;
+import org.briarproject.briar.android.BriarApplication;
+import org.briarproject.briar.android.DestroyableContext;
+import org.briarproject.briar.android.controller.ActivityLifecycleController;
+import org.briarproject.briar.android.forum.ForumModule;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import javax.annotation.Nullable;
+
+import static android.view.WindowManager.LayoutParams.FLAG_SECURE;
+import static android.view.inputmethod.InputMethodManager.SHOW_IMPLICIT;
+import static org.briarproject.briar.android.TestingConstants.PREVENT_SCREENSHOTS;
+
+public abstract class BaseActivity extends AppCompatActivity
+		implements DestroyableContext {
+
+	protected ActivityComponent activityComponent;
+
+	private final List<ActivityLifecycleController> lifecycleControllers =
+			new ArrayList<>();
+	private boolean destroyed = false;
+
+	public abstract void injectActivity(ActivityComponent component);
+
+	public void addLifecycleController(ActivityLifecycleController alc) {
+		lifecycleControllers.add(alc);
+	}
+
+	@Override
+	public void onCreate(@Nullable Bundle savedInstanceState) {
+		super.onCreate(savedInstanceState);
+
+		if (PREVENT_SCREENSHOTS) getWindow().addFlags(FLAG_SECURE);
+
+		AndroidComponent applicationComponent =
+				((BriarApplication) getApplication()).getApplicationComponent();
+
+		activityComponent = DaggerActivityComponent.builder()
+				.androidComponent(applicationComponent)
+				.activityModule(getActivityModule())
+				.forumModule(getForumModule())
+				.build();
+
+		injectActivity(activityComponent);
+
+		for (ActivityLifecycleController alc : lifecycleControllers) {
+			alc.onActivityCreate(this);
+		}
+	}
+
+	public ActivityComponent getActivityComponent() {
+		return activityComponent;
+	}
+
+	// This exists to make test overrides easier
+	protected ActivityModule getActivityModule() {
+		return new ActivityModule(this);
+	}
+
+	protected ForumModule getForumModule() {
+		return new ForumModule();
+	}
+
+	@Override
+	protected void onStart() {
+		super.onStart();
+		for (ActivityLifecycleController alc : lifecycleControllers) {
+			alc.onActivityStart();
+		}
+	}
+
+	@Override
+	protected void onStop() {
+		super.onStop();
+		for (ActivityLifecycleController alc : lifecycleControllers) {
+			alc.onActivityStop();
+		}
+	}
+
+	@Override
+	protected void onDestroy() {
+		super.onDestroy();
+		destroyed = true;
+		for (ActivityLifecycleController alc : lifecycleControllers) {
+			alc.onActivityDestroy();
+		}
+	}
+
+	@Override
+	public void runOnUiThreadUnlessDestroyed(final Runnable r) {
+		runOnUiThread(new Runnable() {
+			@Override
+			public void run() {
+				if (!destroyed && !isFinishing()) r.run();
+			}
+		});
+	}
+
+	public void showSoftKeyboard(View view) {
+		Object o = getSystemService(INPUT_METHOD_SERVICE);
+		((InputMethodManager) o).showSoftInput(view, SHOW_IMPLICIT);
+	}
+
+	public void hideSoftKeyboard(View view) {
+		IBinder token = view.getWindowToken();
+		Object o = getSystemService(INPUT_METHOD_SERVICE);
+		((InputMethodManager) o).hideSoftInputFromWindow(token, 0);
+	}
+}

briar-android/src/main/java/org/briarproject/briar/android/activity/BriarActivity.java

@@ -0,0 +1,105 @@
+package org.briarproject.briar.android.activity;
+
+import android.annotation.SuppressLint;
+import android.content.Intent;
+import android.os.Build;
+
+import org.briarproject.briar.android.controller.BriarController;
+import org.briarproject.briar.android.controller.DbController;
+import org.briarproject.briar.android.controller.handler.UiResultHandler;
+import org.briarproject.briar.android.login.PasswordActivity;
+import org.briarproject.briar.android.panic.ExitActivity;
+
+import java.util.logging.Logger;
+
+import javax.inject.Inject;
+
+import static android.content.Intent.FLAG_ACTIVITY_CLEAR_TASK;
+import static android.content.Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS;
+import static android.content.Intent.FLAG_ACTIVITY_NEW_TASK;
+import static android.content.Intent.FLAG_ACTIVITY_NO_ANIMATION;
+import static android.content.Intent.FLAG_ACTIVITY_SINGLE_TOP;
+
+@SuppressLint("Registered")
+public abstract class BriarActivity extends BaseActivity {
+
+	public static final String KEY_STARTUP_FAILED = "briar.STARTUP_FAILED";
+	public static final String GROUP_ID = "briar.GROUP_ID";
+	public static final String GROUP_NAME = "briar.GROUP_NAME";
+
+	public static final int REQUEST_PASSWORD = 1;
+
+	private static final Logger LOG =
+			Logger.getLogger(BriarActivity.class.getName());
+
+	@Inject
+	BriarController briarController;
+
+	@Deprecated
+	@Inject
+	DbController dbController;
+
+	@Override
+	protected void onActivityResult(int request, int result, Intent data) {
+		super.onActivityResult(request, result, data);
+		if (request == REQUEST_PASSWORD) {
+			if (result == RESULT_OK) briarController.startAndBindService();
+			else finish();
+		}
+	}
+
+	@Override
+	public void onStart() {
+		super.onStart();
+		if (!briarController.hasEncryptionKey() && !isFinishing()) {
+			Intent i = new Intent(this, PasswordActivity.class);
+			i.setFlags(FLAG_ACTIVITY_NO_ANIMATION | FLAG_ACTIVITY_SINGLE_TOP);
+			startActivityForResult(i, REQUEST_PASSWORD);
+		}
+	}
+
+	protected void signOut(final boolean removeFromRecentApps) {
+		briarController.signOut(new UiResultHandler<Void>(this) {
+			@Override
+			public void onResultUi(Void result) {
+				if (removeFromRecentApps) startExitActivity();
+				else finishAndExit();
+			}
+		});
+	}
+
+	protected void signOut() {
+		signOut(false);
+	}
+
+	private void startExitActivity() {
+		Intent i = new Intent(this, ExitActivity.class);
+		i.addFlags(FLAG_ACTIVITY_NEW_TASK
+				| FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS
+				| FLAG_ACTIVITY_NO_ANIMATION
+				| FLAG_ACTIVITY_CLEAR_TASK);
+		startActivity(i);
+	}
+
+	private void finishAndExit() {
+		if (Build.VERSION.SDK_INT >= 21) finishAndRemoveTask();
+		else finish();
+		LOG.info("Exiting");
+		System.exit(0);
+	}
+
+	@Deprecated
+	public void runOnDbThread(Runnable task) {
+		dbController.runOnDbThread(task);
+	}
+
+	@Deprecated
+	protected void finishOnUiThread() {
+		runOnUiThreadUnlessDestroyed(new Runnable() {
+			@Override
+			public void run() {
+				finish();
+			}
+		});
+	}
+}

briar-android/src/main/java/org/briarproject/briar/android/activity/BriarFragmentActivity.java

@@ -0,0 +1,82 @@
+package org.briarproject.briar.android.activity;
+
+import android.support.annotation.AnimRes;
+import android.support.v4.app.FragmentTransaction;
+import android.support.v7.app.AlertDialog;
+
+import org.briarproject.briar.R;
+import org.briarproject.briar.android.contact.ContactListFragment;
+import org.briarproject.briar.android.fragment.BaseFragment;
+import org.briarproject.briar.android.navdrawer.NavDrawerActivity;
+
+import static android.support.v4.app.FragmentManager.POP_BACK_STACK_INCLUSIVE;
+
+/**
+ * This class should be extended by classes that wish to utilise fragments in
+ * Briar, it encapsulates all fragment related code.
+ */
+public abstract class BriarFragmentActivity extends BriarActivity {
+
+	protected void clearBackStack() {
+		getSupportFragmentManager().popBackStackImmediate(null,
+				POP_BACK_STACK_INCLUSIVE);
+	}
+
+	@Override
+	public void onBackPressed() {
+		if (this instanceof NavDrawerActivity &&
+				getSupportFragmentManager().getBackStackEntryCount() == 0 &&
+				getSupportFragmentManager()
+						.findFragmentByTag(ContactListFragment.TAG) == null) {
+			/*
+			This Makes sure that the first fragment (ContactListFragment) the
+			user sees is the same as the last fragment the user sees before
+			exiting. This models the typical Google navigation behaviour such
+			as in Gmail/Inbox.
+			 */
+			startFragment(ContactListFragment.newInstance());
+		} else {
+			super.onBackPressed();
+		}
+	}
+
+	public void onFragmentCreated(String tag) {
+	}
+
+	protected void startFragment(BaseFragment fragment) {
+		if (getSupportFragmentManager().getBackStackEntryCount() == 0)
+			startFragment(fragment, false);
+		else startFragment(fragment, true);
+	}
+
+	protected void showMessageDialog(int titleStringId, int msgStringId) {
+		// TODO replace with custom dialog fragment ?
+		AlertDialog.Builder builder = new AlertDialog.Builder(this,
+				R.style.BriarDialogTheme);
+		builder.setTitle(titleStringId);
+		builder.setMessage(msgStringId);
+		builder.setPositiveButton(R.string.ok, null);
+		AlertDialog dialog = builder.create();
+		dialog.show();
+	}
+
+	public void startFragment(BaseFragment fragment,
+			boolean isAddedToBackStack) {
+		startFragment(fragment, 0, 0, isAddedToBackStack);
+	}
+
+	private void startFragment(BaseFragment fragment,
+			@AnimRes int inAnimation, @AnimRes int outAnimation,
+			boolean isAddedToBackStack) {
+		FragmentTransaction trans =
+				getSupportFragmentManager().beginTransaction();
+		if (inAnimation != 0 && outAnimation != 0) {
+			trans.setCustomAnimations(inAnimation, 0, 0, outAnimation);
+		}
+		trans.replace(R.id.content_fragment, fragment, fragment.getUniqueTag());
+		if (isAddedToBackStack) {
+			trans.addToBackStack(fragment.getUniqueTag());
+		}
+		trans.commit();
+	}
+}

briar-android/src/main/java/org/briarproject/briar/android/blog/BaseController.java

@@ -0,0 +1,51 @@
+package org.briarproject.briar.android.blog;
+
+import android.support.annotation.UiThread;
+
+import org.briarproject.bramble.api.db.DbException;
+import org.briarproject.bramble.api.nullsafety.NotNullByDefault;
+import org.briarproject.bramble.api.sync.GroupId;
+import org.briarproject.bramble.api.sync.MessageId;
+import org.briarproject.briar.android.DestroyableContext;
+import org.briarproject.briar.android.controller.handler.ExceptionHandler;
+import org.briarproject.briar.android.controller.handler.ResultExceptionHandler;
+import org.briarproject.briar.api.blog.BlogPostHeader;
+
+import java.util.Collection;
+
+import javax.annotation.Nullable;
+
+@NotNullByDefault
+interface BaseController {
+
+	@UiThread
+	void onStart();
+
+	@UiThread
+	void onStop();
+
+	void loadBlogPosts(GroupId g,
+			ResultExceptionHandler<Collection<BlogPostItem>, DbException> handler);
+
+	void loadBlogPost(BlogPostHeader header,
+			ResultExceptionHandler<BlogPostItem, DbException> handler);
+
+	void loadBlogPost(GroupId g, MessageId m,
+			ResultExceptionHandler<BlogPostItem, DbException> handler);
+
+	void repeatPost(BlogPostItem item, @Nullable String comment,
+			ExceptionHandler<DbException> handler);
+
+	void setBlogListener(BlogListener listener);
+
+	@NotNullByDefault
+	interface BlogListener extends DestroyableContext {
+
+		@UiThread
+		void onBlogPostAdded(BlogPostHeader header, boolean local);
+
+		@UiThread
+		void onBlogRemoved();
+	}
+
+}

briar-android/src/main/java/org/briarproject/briar/android/blog/BaseControllerImpl.java

@@ -0,0 +1,256 @@
+package org.briarproject.briar.android.blog;
+
+import android.support.annotation.CallSuper;
+
+import org.briarproject.bramble.api.db.DatabaseExecutor;
+import org.briarproject.bramble.api.db.DbException;
+import org.briarproject.bramble.api.event.EventBus;
+import org.briarproject.bramble.api.event.EventListener;
+import org.briarproject.bramble.api.identity.IdentityManager;
+import org.briarproject.bramble.api.identity.LocalAuthor;
+import org.briarproject.bramble.api.lifecycle.LifecycleManager;
+import org.briarproject.bramble.api.nullsafety.MethodsNotNullByDefault;
+import org.briarproject.bramble.api.nullsafety.ParametersNotNullByDefault;
+import org.briarproject.bramble.api.sync.GroupId;
+import org.briarproject.bramble.api.sync.MessageId;
+import org.briarproject.briar.android.controller.DbControllerImpl;
+import org.briarproject.briar.android.controller.handler.ExceptionHandler;
+import org.briarproject.briar.android.controller.handler.ResultExceptionHandler;
+import org.briarproject.briar.api.android.AndroidNotificationManager;
+import org.briarproject.briar.api.blog.Blog;
+import org.briarproject.briar.api.blog.BlogCommentHeader;
+import org.briarproject.briar.api.blog.BlogManager;
+import org.briarproject.briar.api.blog.BlogPostHeader;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.Executor;
+import java.util.logging.Logger;
+
+import javax.annotation.Nullable;
+
+import static java.util.logging.Level.INFO;
+import static java.util.logging.Level.WARNING;
+
+@MethodsNotNullByDefault
+@ParametersNotNullByDefault
+abstract class BaseControllerImpl extends DbControllerImpl
+		implements BaseController, EventListener {
+
+	private static final Logger LOG =
+			Logger.getLogger(BaseControllerImpl.class.getName());
+
+	protected final EventBus eventBus;
+	protected final AndroidNotificationManager notificationManager;
+	protected final IdentityManager identityManager;
+	protected final BlogManager blogManager;
+
+	private final Map<MessageId, String> bodyCache = new ConcurrentHashMap<>();
+	private final Map<MessageId, BlogPostHeader> headerCache =
+			new ConcurrentHashMap<>();
+
+	private volatile BlogListener listener;
+
+	BaseControllerImpl(@DatabaseExecutor Executor dbExecutor,
+			LifecycleManager lifecycleManager, EventBus eventBus,
+			AndroidNotificationManager notificationManager,
+			IdentityManager identityManager, BlogManager blogManager) {
+		super(dbExecutor, lifecycleManager);
+		this.eventBus = eventBus;
+		this.notificationManager = notificationManager;
+		this.identityManager = identityManager;
+		this.blogManager = blogManager;
+	}
+
+	@Override
+	@CallSuper
+	public void onStart() {
+		if (listener == null) throw new IllegalStateException();
+		eventBus.addListener(this);
+	}
+
+	@Override
+	@CallSuper
+	public void onStop() {
+		eventBus.removeListener(this);
+	}
+
+	@Override
+	public void setBlogListener(BlogListener listener) {
+		this.listener = listener;
+	}
+
+	void onBlogPostAdded(final BlogPostHeader h, final boolean local) {
+		listener.runOnUiThreadUnlessDestroyed(new Runnable() {
+			@Override
+			public void run() {
+				listener.onBlogPostAdded(h, local);
+			}
+		});
+	}
+
+	void onBlogRemoved() {
+		listener.runOnUiThreadUnlessDestroyed(new Runnable() {
+			@Override
+			public void run() {
+				listener.onBlogRemoved();
+			}
+		});
+	}
+
+
+	@Override
+	public void loadBlogPosts(final GroupId groupId,
+			final ResultExceptionHandler<Collection<BlogPostItem>, DbException> handler) {
+		runOnDbThread(new Runnable() {
+			@Override
+			public void run() {
+				try {
+					Collection<BlogPostItem> items = loadItems(groupId);
+					handler.onResult(items);
+				} catch (DbException e) {
+					if (LOG.isLoggable(WARNING))
+						LOG.log(WARNING, e.toString(), e);
+					handler.onException(e);
+				}
+			}
+		});
+	}
+
+	Collection<BlogPostItem> loadItems(GroupId groupId) throws DbException {
+		long now = System.currentTimeMillis();
+		Collection<BlogPostHeader> headers =
+				blogManager.getPostHeaders(groupId);
+		long duration = System.currentTimeMillis() - now;
+		if (LOG.isLoggable(INFO))
+			LOG.info("Loading headers took " + duration + " ms");
+		Collection<BlogPostItem> items = new ArrayList<>(headers.size());
+		now = System.currentTimeMillis();
+		for (BlogPostHeader h : headers) {
+			headerCache.put(h.getId(), h);
+			BlogPostItem item = getItem(h);
+			items.add(item);
+		}
+		duration = System.currentTimeMillis() - now;
+		if (LOG.isLoggable(INFO))
+			LOG.info("Loading bodies took " + duration + " ms");
+		return items;
+	}
+
+	@Override
+	public void loadBlogPost(final BlogPostHeader header,
+			final ResultExceptionHandler<BlogPostItem, DbException> handler) {
+
+		String body = bodyCache.get(header.getId());
+		if (body != null) {
+			LOG.info("Loaded body from cache");
+			handler.onResult(new BlogPostItem(header, body));
+			return;
+		}
+		runOnDbThread(new Runnable() {
+			@Override
+			public void run() {
+				try {
+					long now = System.currentTimeMillis();
+					BlogPostItem item = getItem(header);
+					long duration = System.currentTimeMillis() - now;
+					if (LOG.isLoggable(INFO))
+						LOG.info("Loading body took " + duration + " ms");
+					handler.onResult(item);
+				} catch (DbException e) {
+					if (LOG.isLoggable(WARNING))
+						LOG.log(WARNING, e.toString(), e);
+					handler.onException(e);
+				}
+			}
+		});
+	}
+
+	@Override
+	public void loadBlogPost(final GroupId g, final MessageId m,
+			final ResultExceptionHandler<BlogPostItem, DbException> handler) {
+
+		BlogPostHeader header = headerCache.get(m);
+		if (header != null) {
+			LOG.info("Loaded header from cache");
+			loadBlogPost(header, handler);
+			return;
+		}
+		runOnDbThread(new Runnable() {
+			@Override
+			public void run() {
+				try {
+					long now = System.currentTimeMillis();
+					BlogPostHeader header = getPostHeader(g, m);
+					BlogPostItem item = getItem(header);
+					long duration = System.currentTimeMillis() - now;
+					if (LOG.isLoggable(INFO))
+						LOG.info("Loading post took " + duration + " ms");
+					handler.onResult(item);
+				} catch (DbException e) {
+					if (LOG.isLoggable(WARNING))
+						LOG.log(WARNING, e.toString(), e);
+					handler.onException(e);
+				}
+			}
+		});
+	}
+
+	@Override
+	public void repeatPost(final BlogPostItem item,
+			final @Nullable String comment,
+			final ExceptionHandler<DbException> handler) {
+		runOnDbThread(new Runnable() {
+			@Override
+			public void run() {
+				try {
+					LocalAuthor a = identityManager.getLocalAuthor();
+					Blog b = blogManager.getPersonalBlog(a);
+					BlogPostHeader h = item.getHeader();
+					blogManager.addLocalComment(a, b.getId(), comment, h);
+				} catch (DbException e) {
+					if (LOG.isLoggable(WARNING))
+						LOG.log(WARNING, e.toString(), e);
+					handler.onException(e);
+				}
+			}
+		});
+	}
+
+	private BlogPostHeader getPostHeader(GroupId g, MessageId m)
+			throws DbException {
+		BlogPostHeader header = headerCache.get(m);
+		if (header == null) {
+			header = blogManager.getPostHeader(g, m);
+			headerCache.put(m, header);
+		}
+		return header;
+	}
+
+	private BlogPostItem getItem(BlogPostHeader h) throws DbException {
+		String body;
+		if (h instanceof BlogCommentHeader) {
+			BlogCommentHeader c = (BlogCommentHeader) h;
+			BlogCommentItem item = new BlogCommentItem(c);
+			body = getPostBody(item.getPostHeader().getId());
+			item.setBody(body);
+			return item;
+		} else {
+			body = getPostBody(h.getId());
+			return new BlogPostItem(h, body);
+		}
+	}
+
+	private String getPostBody(MessageId m) throws DbException {
+		String body = bodyCache.get(m);
+		if (body == null) {
+			body = blogManager.getPostBody(m);
+			bodyCache.put(m, body);
+		}
+		//noinspection ConstantConditions
+		return body;
+	}
+
+}

briar-android/src/main/java/org/briarproject/briar/android/blog/BasePostFragment.java

@@ -0,0 +1,97 @@
+package org.briarproject.briar.android.blog;
+
+import android.os.Bundle;
+import android.support.annotation.CallSuper;
+import android.support.annotation.UiThread;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.ProgressBar;
+
+import org.briarproject.bramble.api.nullsafety.MethodsNotNullByDefault;
+import org.briarproject.bramble.api.nullsafety.ParametersNotNullByDefault;
+import org.briarproject.briar.R;
+import org.briarproject.briar.android.fragment.BaseFragment;
+
+import java.util.logging.Logger;
+
+import javax.annotation.Nullable;
+
+import static android.view.View.INVISIBLE;
+import static android.view.View.VISIBLE;
+import static org.briarproject.briar.android.util.UiUtils.MIN_RESOLUTION;
+
+@UiThread
+@MethodsNotNullByDefault
+@ParametersNotNullByDefault
+abstract class BasePostFragment extends BaseFragment {
+
+	static final String POST_ID = "briar.POST_ID";
+
+	private static final Logger LOG =
+			Logger.getLogger(BasePostFragment.class.getName());
+
+	private View view;
+	private ProgressBar progressBar;
+	private BlogPostViewHolder ui;
+	private BlogPostItem post;
+	private Runnable refresher;
+
+	@CallSuper
+	@Nullable
+	@Override
+	public View onCreateView(LayoutInflater inflater,
+			@Nullable ViewGroup container,
+			@Nullable Bundle savedInstanceState) {
+		view = inflater.inflate(R.layout.fragment_blog_post, container,
+				false);
+		progressBar = (ProgressBar) view.findViewById(R.id.progressBar);
+		progressBar.setVisibility(VISIBLE);
+		ui = new BlogPostViewHolder(view);
+		return view;
+	}
+
+	@CallSuper
+	@Override
+	public void onStart() {
+		super.onStart();
+		startPeriodicUpdate();
+	}
+
+	@CallSuper
+	@Override
+	public void onStop() {
+		super.onStop();
+		stopPeriodicUpdate();
+	}
+
+	@UiThread
+	protected void onBlogPostLoaded(BlogPostItem post) {
+		progressBar.setVisibility(INVISIBLE);
+		this.post = post;
+		ui.bindItem(post);
+	}
+
+	private void startPeriodicUpdate() {
+		refresher = new Runnable() {
+			@Override
+			public void run() {
+				if (ui == null) return;
+				LOG.info("Updating Content...");
+
+				ui.updateDate(post.getTimestamp());
+				view.postDelayed(refresher, MIN_RESOLUTION);
+			}
+		};
+		LOG.info("Adding Handler Callback");
+		view.postDelayed(refresher, MIN_RESOLUTION);
+	}
+
+	private void stopPeriodicUpdate() {
+		if (refresher != null && ui != null) {
+			LOG.info("Removing Handler Callback");
+			view.removeCallbacks(refresher);
+		}
+	}
+
+}

briar-android/src/main/java/org/briarproject/briar/android/blog/BlogActivity.java

@@ -0,0 +1,62 @@
+package org.briarproject.briar.android.blog;
+
+import android.content.Intent;
+import android.os.Bundle;
+
+import org.briarproject.bramble.api.sync.GroupId;
+import org.briarproject.briar.R;
+import org.briarproject.briar.android.activity.ActivityComponent;
+import org.briarproject.briar.android.activity.BriarActivity;
+import org.briarproject.briar.android.blog.BlogPostAdapter.OnBlogPostClickListener;
+import org.briarproject.briar.android.fragment.BaseFragment.BaseFragmentListener;
+
+import javax.inject.Inject;
+
+public class BlogActivity extends BriarActivity implements
+		OnBlogPostClickListener, BaseFragmentListener {
+
+	static final int REQUEST_WRITE_POST = 1;
+	static final int REQUEST_SHARE = 2;
+
+	@Inject
+	BlogController blogController;
+
+	@Override
+	public void onCreate(Bundle state) {
+		super.onCreate(state);
+
+		// GroupId from Intent
+		Intent i = getIntent();
+		byte[] b = i.getByteArrayExtra(GROUP_ID);
+		if (b == null) throw new IllegalStateException("No group ID in intent");
+		GroupId groupId = new GroupId(b);
+		blogController.setGroupId(groupId);
+
+		setContentView(R.layout.activity_fragment_container);
+
+		if (state == null) {
+			BlogFragment f = BlogFragment.newInstance(groupId);
+			getSupportFragmentManager().beginTransaction()
+					.replace(R.id.fragmentContainer, f, f.getUniqueTag())
+					.commit();
+		}
+	}
+
+	@Override
+	public void injectActivity(ActivityComponent component) {
+		component.inject(this);
+	}
+
+	@Override
+	public void onBlogPostClick(BlogPostItem post) {
+		BlogPostFragment f = BlogPostFragment.newInstance(post.getId());
+		getSupportFragmentManager().beginTransaction()
+				.replace(R.id.fragmentContainer, f, f.getUniqueTag())
+				.addToBackStack(f.getUniqueTag())
+				.commit();
+	}
+
+	@Override
+	public void onFragmentCreated(String tag) {
+	}
+}

briar-android/src/main/java/org/briarproject/briar/android/blog/BlogCommentItem.java

@@ -0,0 +1,63 @@
+package org.briarproject.briar.android.blog;
+
+import org.briarproject.briar.api.blog.BlogCommentHeader;
+import org.briarproject.briar.api.blog.BlogPostHeader;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+
+// This class is not thread-safe
+class BlogCommentItem extends BlogPostItem {
+
+	private static final BlogCommentComparator COMPARATOR =
+			new BlogCommentComparator();
+
+	private final BlogPostHeader postHeader;
+	private final List<BlogCommentHeader> comments = new ArrayList<>();
+
+	BlogCommentItem(BlogCommentHeader header) {
+		super(header, null);
+		postHeader = collectComments(header);
+		Collections.sort(comments, COMPARATOR);
+	}
+
+	private BlogPostHeader collectComments(BlogPostHeader header) {
+		if (header instanceof BlogCommentHeader) {
+			BlogCommentHeader comment = (BlogCommentHeader) header;
+			if (comment.getComment() != null)
+				comments.add(comment);
+			return collectComments(comment.getParent());
+		} else {
+			return header;
+		}
+	}
+
+	public void setBody(String body) {
+		this.body = body;
+	}
+
+	@Override
+	public BlogCommentHeader getHeader() {
+		return (BlogCommentHeader) super.getHeader();
+	}
+
+	@Override
+	BlogPostHeader getPostHeader() {
+		return postHeader;
+	}
+
+	List<BlogCommentHeader> getComments() {
+		return comments;
+	}
+
+	private static class BlogCommentComparator
+			implements Comparator<BlogCommentHeader> {
+		@Override
+		public int compare(BlogCommentHeader h1, BlogCommentHeader h2) {
+			// re-use same comparator used for blog posts, but reverse it
+			return BlogPostItem.compare(h2, h1);
+		}
+	}
+}

briar-android/src/main/java/org/briarproject/briar/android/blog/BlogController.java

@@ -0,0 +1,26 @@
+package org.briarproject.briar.android.blog;
+
+import org.briarproject.bramble.api.db.DbException;
+import org.briarproject.bramble.api.nullsafety.NotNullByDefault;
+import org.briarproject.bramble.api.sync.GroupId;
+import org.briarproject.bramble.api.sync.MessageId;
+import org.briarproject.briar.android.controller.handler.ResultExceptionHandler;
+
+import java.util.Collection;
+
+@NotNullByDefault
+public interface BlogController extends BaseController {
+
+	void setGroupId(GroupId g);
+
+	void loadBlogPosts(
+			ResultExceptionHandler<Collection<BlogPostItem>, DbException> handler);
+
+	void loadBlogPost(MessageId m,
+			ResultExceptionHandler<BlogPostItem, DbException> handler);
+
+	void loadBlog(ResultExceptionHandler<BlogItem, DbException> handler);
+
+	void deleteBlog(ResultExceptionHandler<Void, DbException> handler);
+
+}

briar-android/src/main/java/org/briarproject/briar/android/blog/BlogControllerImpl.java

@@ -0,0 +1,162 @@
+package org.briarproject.briar.android.blog;
+
+import android.app.Activity;
+
+import org.briarproject.bramble.api.db.DatabaseExecutor;
+import org.briarproject.bramble.api.db.DbException;
+import org.briarproject.bramble.api.event.Event;
+import org.briarproject.bramble.api.event.EventBus;
+import org.briarproject.bramble.api.event.EventListener;
+import org.briarproject.bramble.api.identity.IdentityManager;
+import org.briarproject.bramble.api.identity.LocalAuthor;
+import org.briarproject.bramble.api.lifecycle.LifecycleManager;
+import org.briarproject.bramble.api.nullsafety.MethodsNotNullByDefault;
+import org.briarproject.bramble.api.nullsafety.ParametersNotNullByDefault;
+import org.briarproject.bramble.api.sync.GroupId;
+import org.briarproject.bramble.api.sync.MessageId;
+import org.briarproject.bramble.api.sync.event.GroupRemovedEvent;
+import org.briarproject.briar.android.controller.ActivityLifecycleController;
+import org.briarproject.briar.android.controller.handler.ResultExceptionHandler;
+import org.briarproject.briar.api.android.AndroidNotificationManager;
+import org.briarproject.briar.api.blog.Blog;
+import org.briarproject.briar.api.blog.BlogManager;
+import org.briarproject.briar.api.blog.event.BlogPostAddedEvent;
+
+import java.util.Collection;
+import java.util.concurrent.Executor;
+import java.util.logging.Logger;
+
+import javax.inject.Inject;
+
+import static java.util.logging.Level.INFO;
+import static java.util.logging.Level.WARNING;
+
+@MethodsNotNullByDefault
+@ParametersNotNullByDefault
+class BlogControllerImpl extends BaseControllerImpl
+		implements ActivityLifecycleController, BlogController, EventListener {
+
+	private static final Logger LOG =
+			Logger.getLogger(BlogControllerImpl.class.getName());
+
+	private volatile GroupId groupId = null;
+
+	@Inject
+	BlogControllerImpl(@DatabaseExecutor Executor dbExecutor,
+			LifecycleManager lifecycleManager, EventBus eventBus,
+			AndroidNotificationManager notificationManager,
+			IdentityManager identityManager, BlogManager blogManager) {
+		super(dbExecutor, lifecycleManager, eventBus, notificationManager,
+				identityManager, blogManager);
+	}
+
+	@Override
+	public void onActivityCreate(Activity activity) {
+	}
+
+	@Override
+	public void onActivityStart() {
+		super.onStart();
+		notificationManager.blockNotification(groupId);
+		notificationManager.clearBlogPostNotification(groupId);
+	}
+
+	@Override
+	public void onActivityStop() {
+		super.onStop();
+		notificationManager.unblockNotification(groupId);
+	}
+
+	@Override
+	public void onActivityDestroy() {
+	}
+
+	@Override
+	public void setGroupId(GroupId g) {
+		groupId = g;
+	}
+
+	@Override
+	public void eventOccurred(Event e) {
+		if (groupId == null) throw new IllegalStateException();
+		if (e instanceof BlogPostAddedEvent) {
+			BlogPostAddedEvent b = (BlogPostAddedEvent) e;
+			if (b.getGroupId().equals(groupId)) {
+				LOG.info("Blog post added");
+				onBlogPostAdded(b.getHeader(), b.isLocal());
+			}
+		} else if (e instanceof GroupRemovedEvent) {
+			GroupRemovedEvent g = (GroupRemovedEvent) e;
+			if (g.getGroup().getId().equals(groupId)) {
+				LOG.info("Blog removed");
+				onBlogRemoved();
+			}
+		}
+	}
+
+	@Override
+	public void loadBlogPosts(
+			final ResultExceptionHandler<Collection<BlogPostItem>, DbException> handler) {
+		if (groupId == null) throw new IllegalStateException();
+		loadBlogPosts(groupId, handler);
+	}
+
+	@Override
+	public void loadBlogPost(final MessageId m,
+			final ResultExceptionHandler<BlogPostItem, DbException> handler) {
+		if (groupId == null) throw new IllegalStateException();
+		loadBlogPost(groupId, m, handler);
+	}
+
+	@Override
+	public void loadBlog(
+			final ResultExceptionHandler<BlogItem, DbException> handler) {
+		if (groupId == null) throw new IllegalStateException();
+		runOnDbThread(new Runnable() {
+			@Override
+			public void run() {
+				try {
+					long now = System.currentTimeMillis();
+					LocalAuthor a = identityManager.getLocalAuthor();
+					Blog b = blogManager.getBlog(groupId);
+					boolean ours = a.getId().equals(b.getAuthor().getId());
+					boolean removable = blogManager.canBeRemoved(groupId);
+					BlogItem blog = new BlogItem(b, ours, removable);
+					long duration = System.currentTimeMillis() - now;
+					if (LOG.isLoggable(INFO))
+						LOG.info("Loading blog took " + duration + " ms");
+					handler.onResult(blog);
+				} catch (DbException e) {
+					if (LOG.isLoggable(WARNING))
+						LOG.log(WARNING, e.toString(), e);
+					handler.onException(e);
+				}
+			}
+		});
+	}
+
+	@Override
+	public void deleteBlog(
+			final ResultExceptionHandler<Void, DbException> handler) {
+		if (groupId == null) throw new IllegalStateException();
+		runOnDbThread(new Runnable() {
+			@Override
+			public void run() {
+				try {
+					long now = System.currentTimeMillis();
+					Blog b = blogManager.getBlog(groupId);
+					blogManager.removeBlog(b);
+					long duration = System.currentTimeMillis() - now;
+					if (LOG.isLoggable(INFO))
+						LOG.info("Removing blog took " + duration + " ms");
+					handler.onResult(null);
+				} catch (DbException e) {
+					if (LOG.isLoggable(WARNING))
+						LOG.log(WARNING, e.toString(), e);
+					handler.onException(e);
+				}
+			}
+		});
+	}
+
+}

briar-android/src/main/java/org/briarproject/briar/android/blog/BlogFragment.java

@@ -0,0 +1,330 @@
+package org.briarproject.briar.android.blog;
+
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.os.Bundle;
+import android.support.annotation.UiThread;
+import android.support.design.widget.Snackbar;
+import android.support.v4.app.ActivityOptionsCompat;
+import android.support.v4.content.ContextCompat;
+import android.support.v7.app.AlertDialog;
+import android.support.v7.widget.LinearLayoutManager;
+import android.view.LayoutInflater;
+import android.view.Menu;
+import android.view.MenuInflater;
+import android.view.MenuItem;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.Toast;
+
+import org.briarproject.bramble.api.db.DbException;
+import org.briarproject.bramble.api.identity.Author;
+import org.briarproject.bramble.api.nullsafety.MethodsNotNullByDefault;
+import org.briarproject.bramble.api.nullsafety.ParametersNotNullByDefault;
+import org.briarproject.bramble.api.sync.GroupId;
+import org.briarproject.briar.R;
+import org.briarproject.briar.android.activity.ActivityComponent;
+import org.briarproject.briar.android.blog.BaseController.BlogListener;
+import org.briarproject.briar.android.blog.BlogPostAdapter.OnBlogPostClickListener;
+import org.briarproject.briar.android.controller.handler.UiResultExceptionHandler;
+import org.briarproject.briar.android.fragment.BaseFragment;
+import org.briarproject.briar.android.sharing.BlogSharingStatusActivity;
+import org.briarproject.briar.android.sharing.ShareBlogActivity;
+import org.briarproject.briar.android.view.BriarRecyclerView;
+import org.briarproject.briar.api.blog.BlogPostHeader;
+
+import java.util.Collection;
+
+import javax.annotation.Nullable;
+import javax.inject.Inject;
+
+import static android.app.Activity.RESULT_OK;
+import static android.content.Intent.FLAG_ACTIVITY_CLEAR_TOP;
+import static android.content.Intent.FLAG_ACTIVITY_SINGLE_TOP;
+import static android.support.v4.app.ActivityOptionsCompat.makeCustomAnimation;
+import static android.widget.Toast.LENGTH_SHORT;
+import static org.briarproject.briar.android.activity.BriarActivity.GROUP_ID;
+import static org.briarproject.briar.android.blog.BlogActivity.REQUEST_SHARE;
+import static org.briarproject.briar.android.blog.BlogActivity.REQUEST_WRITE_POST;
+
+@UiThread
+@MethodsNotNullByDefault
+@ParametersNotNullByDefault
+public class BlogFragment extends BaseFragment implements
+		BlogListener {
+
+	private final static String TAG = BlogFragment.class.getName();
+
+	@Inject
+	BlogController blogController;
+
+	private GroupId groupId;
+	private BlogPostAdapter adapter;
+	private BriarRecyclerView list;
+	private MenuItem writeButton, deleteButton;
+	private boolean isMyBlog = false, canDeleteBlog = false;
+
+	static BlogFragment newInstance(GroupId groupId) {
+
+		BlogFragment f = new BlogFragment();
+
+		Bundle bundle = new Bundle();
+		bundle.putByteArray(GROUP_ID, groupId.getBytes());
+
+		f.setArguments(bundle);
+		return f;
+	}
+
+	@Nullable
+	@Override
+	public View onCreateView(LayoutInflater inflater,
+			@Nullable ViewGroup container,
+			@Nullable Bundle savedInstanceState) {
+		Bundle args = getArguments();
+		byte[] b = args.getByteArray(GROUP_ID);
+		if (b == null) throw new IllegalStateException("No group ID in args");
+		groupId = new GroupId(b);
+
+		View v = inflater.inflate(R.layout.fragment_blog, container, false);
+
+		adapter = new BlogPostAdapter(getActivity(),
+				(OnBlogPostClickListener) getActivity());
+		list = (BriarRecyclerView) v.findViewById(R.id.postList);
+		list.setLayoutManager(new LinearLayoutManager(getActivity()));
+		list.setAdapter(adapter);
+		list.showProgressBar();
+		list.setEmptyText(getString(R.string.blogs_other_blog_empty_state));
+
+		return v;
+	}
+
+	@Override
+	public void injectFragment(ActivityComponent component) {
+		component.inject(this);
+		blogController.setBlogListener(this);
+	}
+
+	@Override
+	public void onStart() {
+		super.onStart();
+		loadBlog();
+		loadBlogPosts(false);
+		list.startPeriodicUpdate();
+	}
+
+	@Override
+	public void onStop() {
+		super.onStop();
+		list.stopPeriodicUpdate();
+	}
+
+	@Override
+	public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
+		inflater.inflate(R.menu.blogs_blog_actions, menu);
+		writeButton = menu.findItem(R.id.action_write_blog_post);
+		if (isMyBlog) writeButton.setVisible(true);
+		deleteButton = menu.findItem(R.id.action_blog_delete);
+		if (canDeleteBlog) deleteButton.setEnabled(true);
+
+		super.onCreateOptionsMenu(menu, inflater);
+	}
+
+	@Override
+	public boolean onOptionsItemSelected(final MenuItem item) {
+		ActivityOptionsCompat options =
+				makeCustomAnimation(getActivity(),
+						android.R.anim.slide_in_left,
+						android.R.anim.slide_out_right);
+		switch (item.getItemId()) {
+			case R.id.action_write_blog_post:
+				Intent i = new Intent(getActivity(),
+						WriteBlogPostActivity.class);
+				i.putExtra(GROUP_ID, groupId.getBytes());
+				startActivityForResult(i, REQUEST_WRITE_POST,
+						options.toBundle());
+				return true;
+			case R.id.action_blog_share:
+				Intent i2 = new Intent(getActivity(), ShareBlogActivity.class);
+				i2.setFlags(FLAG_ACTIVITY_CLEAR_TOP | FLAG_ACTIVITY_SINGLE_TOP);
+				i2.putExtra(GROUP_ID, groupId.getBytes());
+				startActivityForResult(i2, REQUEST_SHARE, options.toBundle());
+				return true;
+			case R.id.action_blog_sharing_status:
+				Intent i3 = new Intent(getActivity(),
+						BlogSharingStatusActivity.class);
+				i3.setFlags(FLAG_ACTIVITY_CLEAR_TOP | FLAG_ACTIVITY_SINGLE_TOP);
+				i3.putExtra(GROUP_ID, groupId.getBytes());
+				startActivity(i3, options.toBundle());
+				return true;
+			case R.id.action_blog_delete:
+				showDeleteDialog();
+				return true;
+			default:
+				return super.onOptionsItemSelected(item);
+		}
+	}
+
+	@Override
+	public void onActivityResult(int request, int result, Intent data) {
+		super.onActivityResult(request, result, data);
+
+		if (request == REQUEST_WRITE_POST && result == RESULT_OK) {
+			displaySnackbar(R.string.blogs_blog_post_created, true);
+			loadBlogPosts(true);
+		} else if (request == REQUEST_SHARE && result == RESULT_OK) {
+			displaySnackbar(R.string.blogs_sharing_snackbar, false);
+		}
+	}
+
+	@Override
+	public String getUniqueTag() {
+		return TAG;
+	}
+
+	@Override
+	public void onBlogPostAdded(BlogPostHeader header, final boolean local) {
+		blogController.loadBlogPost(header,
+				new UiResultExceptionHandler<BlogPostItem, DbException>(
+						this) {
+					@Override
+					public void onResultUi(BlogPostItem post) {
+						adapter.add(post);
+						if (local) {
+							list.scrollToPosition(0);
+							displaySnackbar(R.string.blogs_blog_post_created,
+									false);
+						} else {
+							displaySnackbar(R.string.blogs_blog_post_received,
+									true);
+						}
+					}
+
+					@Override
+					public void onExceptionUi(DbException exception) {
+						// TODO: Decide how to handle errors in the UI
+						finish();
+					}
+				}
+		);
+	}
+
+	private void loadBlogPosts(final boolean reload) {
+		blogController.loadBlogPosts(
+				new UiResultExceptionHandler<Collection<BlogPostItem>, DbException>(
+						this) {
+					@Override
+					public void onResultUi(Collection<BlogPostItem> posts) {
+						if (posts.isEmpty()) {
+							list.showData();
+						} else {
+							adapter.addAll(posts);
+							if (reload) list.scrollToPosition(0);
+						}
+					}
+
+					@Override
+					public void onExceptionUi(DbException exception) {
+						// TODO: Decide how to handle errors in the UI
+						finish();
+					}
+				});
+	}
+
+	private void loadBlog() {
+		blogController.loadBlog(
+				new UiResultExceptionHandler<BlogItem, DbException>(this) {
+					@Override
+					public void onResultUi(BlogItem blog) {
+						setToolbarTitle(blog.getBlog().getAuthor());
+						if (blog.isOurs())
+							showWriteButton();
+						if (blog.canBeRemoved())
+							enableDeleteButton();
+					}
+
+					@Override
+					public void onExceptionUi(DbException exception) {
+						// TODO: Decide how to handle errors in the UI
+						finish();
+					}
+				});
+	}
+
+	private void setToolbarTitle(Author a) {
+		String title = getString(R.string.blogs_personal_blog, a.getName());
+		getActivity().setTitle(title);
+	}
+
+	private void showWriteButton() {
+		isMyBlog = true;
+		if (writeButton != null)
+			writeButton.setVisible(true);
+	}
+
+	private void enableDeleteButton() {
+		canDeleteBlog = true;
+		if (deleteButton != null)
+			deleteButton.setEnabled(true);
+	}
+
+	private void displaySnackbar(int stringId, boolean scroll) {
+		Snackbar snackbar =
+				Snackbar.make(list, stringId, Snackbar.LENGTH_LONG);
+		snackbar.getView().setBackgroundResource(R.color.briar_primary);
+		if (scroll) {
+			View.OnClickListener onClick = new View.OnClickListener() {
+				@Override
+				public void onClick(View v) {
+					list.smoothScrollToPosition(0);
+				}
+			};
+			snackbar.setActionTextColor(ContextCompat
+					.getColor(getContext(),
+							R.color.briar_button_positive));
+			snackbar.setAction(R.string.blogs_blog_post_scroll_to, onClick);
+		}
+		snackbar.show();
+	}
+
+	private void showDeleteDialog() {
+		DialogInterface.OnClickListener okListener =
+				new DialogInterface.OnClickListener() {
+					@Override
+					public void onClick(DialogInterface dialog, int which) {
+						deleteBlog();
+					}
+				};
+		AlertDialog.Builder builder = new AlertDialog.Builder(getActivity(),
+				R.style.BriarDialogTheme);
+		builder.setTitle(getString(R.string.blogs_remove_blog));
+		builder.setMessage(
+				getString(R.string.blogs_remove_blog_dialog_message));
+		builder.setPositiveButton(R.string.cancel, null);
+		builder.setNegativeButton(R.string.blogs_remove_blog_ok, okListener);
+		builder.show();
+	}
+
+	private void deleteBlog() {
+		blogController.deleteBlog(
+				new UiResultExceptionHandler<Void, DbException>(this) {
+					@Override
+					public void onResultUi(Void result) {
+						Toast.makeText(getActivity(),
+								R.string.blogs_blog_removed, LENGTH_SHORT)
+								.show();
+						finish();
+					}
+
+					@Override
+					public void onExceptionUi(DbException exception) {
+						// TODO: Decide how to handle errors in the UI
+						finish();
+					}
+				});
+	}
+
+	@Override
+	public void onBlogRemoved() {
+		finish();
+	}
+}

briar-android/src/main/java/org/briarproject/briar/android/blog/BlogItem.java

@@ -0,0 +1,27 @@
+package org.briarproject.briar.android.blog;
+
+import org.briarproject.briar.api.blog.Blog;
+
+class BlogItem {
+
+	private final Blog blog;
+	private final boolean ours, removable;
+
+	BlogItem(Blog blog, boolean ours, boolean removable) {
+		this.blog = blog;
+		this.ours = ours;
+		this.removable = removable;
+	}
+
+	Blog getBlog() {
+		return blog;
+	}
+
+	boolean isOurs() {
+		return ours;
+	}
+
+	boolean canBeRemoved() {
+		return removable;
+	}
+}

briar-android/src/main/java/org/briarproject/briar/android/blog/BlogModule.java

@@ -0,0 +1,25 @@
+package org.briarproject.briar.android.blog;
+
+import org.briarproject.briar.android.activity.ActivityScope;
+import org.briarproject.briar.android.activity.BaseActivity;
+
+import dagger.Module;
+import dagger.Provides;
+
+@Module
+public class BlogModule {
+
+	@ActivityScope
+	@Provides
+	BlogController provideBlogController(BaseActivity activity,
+			BlogControllerImpl blogController) {
+		activity.addLifecycleController(blogController);
+		return blogController;
+	}
+
+	@ActivityScope
+	@Provides
+	FeedController provideFeedController(FeedControllerImpl feedController) {
+		return feedController;
+	}
+}

briar-android/src/main/java/org/briarproject/briar/android/blog/BlogPostAdapter.java

@@ -0,0 +1,55 @@
+package org.briarproject.briar.android.blog;
+
+import android.content.Context;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+
+import org.briarproject.briar.R;
+import org.briarproject.briar.android.util.BriarAdapter;
+
+class BlogPostAdapter
+		extends BriarAdapter<BlogPostItem, BlogPostViewHolder> {
+
+	private final OnBlogPostClickListener listener;
+
+	BlogPostAdapter(Context ctx, OnBlogPostClickListener listener) {
+		super(ctx, BlogPostItem.class);
+		this.listener = listener;
+	}
+
+	@Override
+	public BlogPostViewHolder onCreateViewHolder(ViewGroup parent,
+			int viewType) {
+		View v = LayoutInflater.from(ctx).inflate(
+				R.layout.list_item_blog_post, parent, false);
+		BlogPostViewHolder ui = new BlogPostViewHolder(v);
+		ui.setOnBlogPostClickListener(listener);
+		return ui;
+	}
+
+	@Override
+	public void onBindViewHolder(BlogPostViewHolder ui, int position) {
+		ui.bindItem(getItemAt(position));
+	}
+
+	@Override
+	public int compare(BlogPostItem a, BlogPostItem b) {
+		return a.compareTo(b);
+	}
+
+	@Override
+	public boolean areContentsTheSame(BlogPostItem a, BlogPostItem b) {
+		return a.isRead() == b.isRead();
+	}
+
+	@Override
+	public boolean areItemsTheSame(BlogPostItem a, BlogPostItem b) {
+		return a.getId().equals(b.getId());
+	}
+
+	interface OnBlogPostClickListener {
+		void onBlogPostClick(BlogPostItem post);
+	}
+
+}

briar-android/src/main/java/org/briarproject/briar/android/blog/BlogPostFragment.java

@@ -0,0 +1,83 @@
+package org.briarproject.briar.android.blog;
+
+import android.os.Bundle;
+import android.support.annotation.UiThread;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+
+import org.briarproject.bramble.api.db.DbException;
+import org.briarproject.bramble.api.nullsafety.MethodsNotNullByDefault;
+import org.briarproject.bramble.api.nullsafety.ParametersNotNullByDefault;
+import org.briarproject.bramble.api.sync.MessageId;
+import org.briarproject.briar.android.activity.ActivityComponent;
+import org.briarproject.briar.android.controller.handler.UiResultExceptionHandler;
+
+import javax.annotation.Nullable;
+import javax.inject.Inject;
+
+@UiThread
+@MethodsNotNullByDefault
+@ParametersNotNullByDefault
+public class BlogPostFragment extends BasePostFragment {
+
+	private static final String TAG = BlogPostFragment.class.getName();
+
+	private MessageId postId;
+
+	@Inject
+	BlogController blogController;
+
+	static BlogPostFragment newInstance(MessageId postId) {
+		BlogPostFragment f = new BlogPostFragment();
+
+		Bundle bundle = new Bundle();
+		bundle.putByteArray(POST_ID, postId.getBytes());
+
+		f.setArguments(bundle);
+		return f;
+	}
+
+	@Nullable
+	@Override
+	public View onCreateView(LayoutInflater inflater,
+			@Nullable ViewGroup container,
+			@Nullable Bundle savedInstanceState) {
+
+		Bundle args = getArguments();
+		byte[] p = args.getByteArray(POST_ID);
+		if (p == null) throw new IllegalStateException("No post ID in args");
+		postId = new MessageId(p);
+
+		return super.onCreateView(inflater, container, savedInstanceState);
+	}
+
+	@Override
+	public String getUniqueTag() {
+		return TAG;
+	}
+
+	@Override
+	public void injectFragment(ActivityComponent component) {
+		component.inject(this);
+	}
+
+	@Override
+	public void onStart() {
+		super.onStart();
+		blogController.loadBlogPost(postId,
+				new UiResultExceptionHandler<BlogPostItem, DbException>(
+						this) {
+					@Override
+					public void onResultUi(BlogPostItem post) {
+						onBlogPostLoaded(post);
+					}
+
+					@Override
+					public void onExceptionUi(DbException exception) {
+						// TODO: Decide how to handle errors in the UI
+						finish();
+					}
+				});
+	}
+}

briar-android/src/main/java/org/briarproject/briar/android/blog/BlogPostItem.java

@@ -0,0 +1,76 @@
+package org.briarproject.briar.android.blog;
+
+import android.support.annotation.NonNull;
+
+import org.briarproject.bramble.api.identity.Author;
+import org.briarproject.bramble.api.identity.Author.Status;
+import org.briarproject.bramble.api.sync.GroupId;
+import org.briarproject.bramble.api.sync.MessageId;
+import org.briarproject.briar.api.blog.BlogPostHeader;
+
+import javax.annotation.Nullable;
+import javax.annotation.concurrent.NotThreadSafe;
+
+@NotThreadSafe
+public class BlogPostItem implements Comparable<BlogPostItem> {
+
+	private final BlogPostHeader header;
+	protected String body;
+	private boolean read;
+
+	BlogPostItem(BlogPostHeader header, @Nullable String body) {
+		this.header = header;
+		this.body = body;
+		this.read = header.isRead();
+	}
+
+	public MessageId getId() {
+		return header.getId();
+	}
+
+	public GroupId getGroupId() {
+		return header.getGroupId();
+	}
+
+	public long getTimestamp() {
+		return header.getTimestamp();
+	}
+
+	public Author getAuthor() {
+		return header.getAuthor();
+	}
+
+	Status getAuthorStatus() {
+		return header.getAuthorStatus();
+	}
+
+	public String getBody() {
+		return body;
+	}
+
+	public boolean isRead() {
+		return read;
+	}
+
+	public BlogPostHeader getHeader() {
+		return header;
+	}
+
+	BlogPostHeader getPostHeader() {
+		return getHeader();
+	}
+
+	@Override
+	public int compareTo(@NonNull BlogPostItem other) {
+		if (this == other) return 0;
+		return compare(getHeader(), other.getHeader());
+	}
+
+	protected static int compare(BlogPostHeader h1, BlogPostHeader h2) {
+		// The newest post comes first
+		long aTime = h1.getTimeReceived(), bTime = h2.getTimeReceived();
+		if (aTime > bTime) return -1;
+		if (aTime < bTime) return 1;
+		return 0;
+	}
+}

briar-android/src/main/java/org/briarproject/briar/android/blog/BlogPostViewHolder.java

@@ -0,0 +1,193 @@
+package org.briarproject.briar.android.blog;
+
+import android.app.Activity;
+import android.content.Context;
+import android.content.Intent;
+import android.os.Build;
+import android.support.annotation.UiThread;
+import android.support.v4.app.ActivityCompat;
+import android.support.v4.app.ActivityOptionsCompat;
+import android.support.v4.view.ViewCompat;
+import android.support.v7.widget.RecyclerView;
+import android.text.Spanned;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.view.ViewGroup;
+import android.widget.ImageView;
+import android.widget.TextView;
+
+import org.briarproject.bramble.api.identity.Author;
+import org.briarproject.bramble.api.sync.MessageId;
+import org.briarproject.briar.R;
+import org.briarproject.briar.android.blog.BlogPostAdapter.OnBlogPostClickListener;
+import org.briarproject.briar.android.view.AuthorView;
+import org.briarproject.briar.api.blog.BlogCommentHeader;
+import org.briarproject.briar.api.blog.BlogPostHeader;
+
+import javax.annotation.Nullable;
+
+import static android.support.v4.app.ActivityOptionsCompat.makeSceneTransitionAnimation;
+import static android.view.View.GONE;
+import static android.view.View.VISIBLE;
+import static org.briarproject.briar.android.activity.BriarActivity.GROUP_ID;
+import static org.briarproject.briar.android.blog.BasePostFragment.POST_ID;
+import static org.briarproject.briar.android.util.UiUtils.TEASER_LENGTH;
+import static org.briarproject.briar.android.util.UiUtils.getSpanned;
+import static org.briarproject.briar.android.util.UiUtils.getTeaser;
+import static org.briarproject.briar.android.util.UiUtils.makeLinksClickable;
+import static org.briarproject.briar.api.blog.MessageType.POST;
+
+@UiThread
+class BlogPostViewHolder extends RecyclerView.ViewHolder {
+
+	private final Context ctx;
+	private final ViewGroup layout;
+	private final AuthorView reblogger;
+	private final AuthorView author;
+	private final ImageView reblogButton;
+	private final TextView body;
+	private final ViewGroup commentContainer;
+
+	private OnBlogPostClickListener listener;
+
+	BlogPostViewHolder(View v) {
+		super(v);
+
+		ctx = v.getContext();
+		layout = (ViewGroup) v.findViewById(R.id.postLayout);
+		reblogger = (AuthorView) v.findViewById(R.id.rebloggerView);
+		author = (AuthorView) v.findViewById(R.id.authorView);
+		reblogButton = (ImageView) v.findViewById(R.id.commentView);
+		body = (TextView) v.findViewById(R.id.bodyView);
+		commentContainer =
+				(ViewGroup) v.findViewById(R.id.commentContainer);
+	}
+
+	void setOnBlogPostClickListener(OnBlogPostClickListener listener) {
+		this.listener = listener;
+	}
+
+	void setVisibility(int visibility) {
+		layout.setVisibility(visibility);
+	}
+
+	void hideReblogButton() {
+		reblogButton.setVisibility(GONE);
+	}
+
+	void updateDate(long time) {
+		author.setDate(time);
+	}
+
+	void setTransitionName(MessageId id) {
+		ViewCompat.setTransitionName(layout, getTransitionName(id));
+	}
+
+	private String getTransitionName(MessageId id) {
+		return "blogPost" + id.hashCode();
+	}
+
+	void bindItem(@Nullable final BlogPostItem item) {
+		if (item == null) return;
+
+		setTransitionName(item.getId());
+		if (listener != null) {
+			layout.setClickable(true);
+			layout.setOnClickListener(new OnClickListener() {
+				@Override
+				public void onClick(View v) {
+					listener.onBlogPostClick(item);
+				}
+			});
+		}
+
+		// author and date
+		BlogPostHeader post = item.getPostHeader();
+		Author a = post.getAuthor();
+		author.setAuthor(a);
+		author.setAuthorStatus(post.getAuthorStatus());
+		author.setDate(post.getTimestamp());
+		author.setPersona(AuthorView.NORMAL);
+		// TODO make author clickable more often #624
+		if (item.getHeader().getType() == POST) {
+			author.setBlogLink(post.getGroupId());
+		} else {
+			author.unsetBlogLink();
+		}
+
+		// post body
+		Spanned bodyText = getSpanned(item.getBody());
+		if (listener == null) {
+			body.setText(bodyText);
+			body.setTextIsSelectable(true);
+			makeLinksClickable(body);
+		} else {
+			body.setTextIsSelectable(false);
+			if (bodyText.length() > TEASER_LENGTH)
+				bodyText = getTeaser(ctx, bodyText);
+			body.setText(bodyText);
+		}
+
+		// reblog button
+		reblogButton.setOnClickListener(new OnClickListener() {
+			@Override
+			public void onClick(View v) {
+				Intent i = new Intent(ctx, ReblogActivity.class);
+				i.putExtra(GROUP_ID, item.getGroupId().getBytes());
+				i.putExtra(POST_ID, item.getId().getBytes());
+
+				// work-around for android bug #224270
+				if (Build.VERSION.SDK_INT >= 23) {
+					ActivityOptionsCompat options =
+							makeSceneTransitionAnimation((Activity) ctx, layout,
+									getTransitionName(item.getId()));
+					ActivityCompat
+							.startActivity((Activity) ctx, i,
+									options.toBundle());
+				} else {
+					ctx.startActivity(i);
+				}
+			}
+		});
+
+		// comments
+		commentContainer.removeAllViews();
+		if (item instanceof BlogCommentItem) {
+			onBindComment((BlogCommentItem) item);
+		} else {
+			reblogger.setVisibility(GONE);
+		}
+	}
+
+	private void onBindComment(final BlogCommentItem item) {
+		// reblogger
+		reblogger.setAuthor(item.getAuthor());
+		reblogger.setAuthorStatus(item.getAuthorStatus());
+		reblogger.setDate(item.getTimestamp());
+		reblogger.setBlogLink(item.getGroupId());
+		reblogger.setVisibility(VISIBLE);
+
+		author.setPersona(AuthorView.COMMENTER);
+
+		// comments
+		for (BlogCommentHeader c : item.getComments()) {
+			View v = LayoutInflater.from(ctx)
+					.inflate(R.layout.list_item_blog_comment,
+							commentContainer, false);
+
+			AuthorView author = (AuthorView) v.findViewById(R.id.authorView);
+			TextView body = (TextView) v.findViewById(R.id.bodyView);
+
+			author.setAuthor(c.getAuthor());
+			author.setAuthorStatus(c.getAuthorStatus());
+			author.setDate(c.getTimestamp());
+			// TODO make author clickable #624
+
+			body.setText(c.getComment());
+			if (listener == null) body.setTextIsSelectable(true);
+
+			commentContainer.addView(v);
+		}
+	}
+}

briar-android/src/main/java/org/briarproject/briar/android/blog/FeedController.java

@@ -0,0 +1,28 @@
+package org.briarproject.briar.android.blog;
+
+import android.support.annotation.UiThread;
+
+import org.briarproject.bramble.api.db.DbException;
+import org.briarproject.bramble.api.nullsafety.NotNullByDefault;
+import org.briarproject.briar.android.controller.handler.ResultExceptionHandler;
+import org.briarproject.briar.api.blog.Blog;
+
+import java.util.Collection;
+
+@NotNullByDefault
+public interface FeedController extends BaseController {
+
+	void loadBlogPosts(
+			ResultExceptionHandler<Collection<BlogPostItem>, DbException> handler);
+
+	void loadPersonalBlog(ResultExceptionHandler<Blog, DbException> handler);
+
+	void setFeedListener(FeedListener listener);
+
+	@NotNullByDefault
+	interface FeedListener extends BlogListener {
+
+		@UiThread
+		void onBlogAdded();
+	}
+}

briar-android/src/main/java/org/briarproject/briar/android/blog/FeedControllerImpl.java

@@ -0,0 +1,155 @@
+package org.briarproject.briar.android.blog;
+
+import org.briarproject.bramble.api.db.DatabaseExecutor;
+import org.briarproject.bramble.api.db.DbException;
+import org.briarproject.bramble.api.db.NoSuchGroupException;
+import org.briarproject.bramble.api.db.NoSuchMessageException;
+import org.briarproject.bramble.api.event.Event;
+import org.briarproject.bramble.api.event.EventBus;
+import org.briarproject.bramble.api.identity.Author;
+import org.briarproject.bramble.api.identity.IdentityManager;
+import org.briarproject.bramble.api.lifecycle.LifecycleManager;
+import org.briarproject.bramble.api.nullsafety.MethodsNotNullByDefault;
+import org.briarproject.bramble.api.nullsafety.ParametersNotNullByDefault;
+import org.briarproject.bramble.api.sync.event.GroupAddedEvent;
+import org.briarproject.bramble.api.sync.event.GroupRemovedEvent;
+import org.briarproject.briar.android.controller.handler.ResultExceptionHandler;
+import org.briarproject.briar.api.android.AndroidNotificationManager;
+import org.briarproject.briar.api.blog.Blog;
+import org.briarproject.briar.api.blog.BlogManager;
+import org.briarproject.briar.api.blog.event.BlogPostAddedEvent;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.concurrent.Executor;
+import java.util.logging.Logger;
+
+import javax.inject.Inject;
+
+import static java.util.logging.Level.INFO;
+import static java.util.logging.Level.WARNING;
+import static org.briarproject.briar.api.blog.BlogManager.CLIENT_ID;
+
+@MethodsNotNullByDefault
+@ParametersNotNullByDefault
+class FeedControllerImpl extends BaseControllerImpl
+		implements FeedController {
+
+	private static final Logger LOG =
+			Logger.getLogger(FeedControllerImpl.class.getName());
+
+	private volatile FeedListener listener;
+
+	@Inject
+	FeedControllerImpl(@DatabaseExecutor Executor dbExecutor,
+			LifecycleManager lifecycleManager, EventBus eventBus,
+			AndroidNotificationManager notificationManager,
+			IdentityManager identityManager, BlogManager blogManager) {
+		super(dbExecutor, lifecycleManager, eventBus, notificationManager,
+				identityManager, blogManager);
+	}
+
+	@Override
+	public void onStart() {
+		super.onStart();
+		if (listener == null) throw new IllegalStateException();
+		notificationManager.blockAllBlogPostNotifications();
+		notificationManager.clearAllBlogPostNotifications();
+	}
+
+	@Override
+	public void onStop() {
+		super.onStop();
+		notificationManager.unblockAllBlogPostNotifications();
+	}
+
+	@Override
+	public void setFeedListener(FeedListener listener) {
+		super.setBlogListener(listener);
+		this.listener = listener;
+	}
+
+	@Override
+	public void eventOccurred(Event e) {
+		if (e instanceof BlogPostAddedEvent) {
+			BlogPostAddedEvent b = (BlogPostAddedEvent) e;
+			LOG.info("Blog post added");
+			onBlogPostAdded(b.getHeader(), b.isLocal());
+		} else if (e instanceof GroupAddedEvent) {
+			GroupAddedEvent g = (GroupAddedEvent) e;
+			if (g.getGroup().getClientId().equals(CLIENT_ID)) {
+				LOG.info("Blog added");
+				onBlogAdded();
+			}
+		} else if (e instanceof GroupRemovedEvent) {
+			GroupRemovedEvent g = (GroupRemovedEvent) e;
+			if (g.getGroup().getClientId().equals(CLIENT_ID)) {
+				LOG.info("Blog removed");
+				onBlogRemoved();
+			}
+		}
+	}
+
+	private void onBlogAdded() {
+		listener.runOnUiThreadUnlessDestroyed(new Runnable() {
+			@Override
+			public void run() {
+				listener.onBlogAdded();
+			}
+		});
+	}
+
+	@Override
+	public void loadBlogPosts(
+			final ResultExceptionHandler<Collection<BlogPostItem>, DbException> handler) {
+		runOnDbThread(new Runnable() {
+			@Override
+			public void run() {
+				try {
+					long now = System.currentTimeMillis();
+					Collection<BlogPostItem> posts = new ArrayList<>();
+					for (Blog b : blogManager.getBlogs()) {
+						try {
+							posts.addAll(loadItems(b.getId()));
+						} catch (NoSuchGroupException | NoSuchMessageException e) {
+							if (LOG.isLoggable(WARNING))
+								LOG.log(WARNING, e.toString(), e);
+						}
+					}
+					long duration = System.currentTimeMillis() - now;
+					if (LOG.isLoggable(INFO))
+						LOG.info("Loading all posts took " + duration + " ms");
+					handler.onResult(posts);
+				} catch (DbException e) {
+					if (LOG.isLoggable(WARNING))
+						LOG.log(WARNING, e.toString(), e);
+					handler.onException(e);
+				}
+			}
+		});
+	}
+
+	@Override
+	public void loadPersonalBlog(
+			final ResultExceptionHandler<Blog, DbException> handler) {
+		runOnDbThread(new Runnable() {
+			@Override
+			public void run() {
+				try {
+					long now = System.currentTimeMillis();
+					Author a = identityManager.getLocalAuthor();
+					Blog b = blogManager.getPersonalBlog(a);
+					long duration = System.currentTimeMillis() - now;
+					if (LOG.isLoggable(INFO))
+						LOG.info("Loading blog took " + duration + " ms");
+					handler.onResult(b);
+				} catch (DbException e) {
+					if (LOG.isLoggable(WARNING))
+						LOG.log(WARNING, e.toString(), e);
+					handler.onException(e);
+				}
+			}
+		});
+	}
+
+}

briar-android/src/main/java/org/briarproject/briar/android/blog/FeedFragment.java

@@ -0,0 +1,272 @@
+package org.briarproject.briar.android.blog;
+
+import android.content.Intent;
+import android.os.Bundle;
+import android.support.annotation.UiThread;
+import android.support.design.widget.Snackbar;
+import android.support.v4.app.ActivityOptionsCompat;
+import android.support.v4.content.ContextCompat;
+import android.support.v7.widget.LinearLayoutManager;
+import android.view.LayoutInflater;
+import android.view.Menu;
+import android.view.MenuInflater;
+import android.view.MenuItem;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.view.ViewGroup;
+
+import org.briarproject.bramble.api.db.DbException;
+import org.briarproject.bramble.api.nullsafety.MethodsNotNullByDefault;
+import org.briarproject.bramble.api.nullsafety.ParametersNotNullByDefault;
+import org.briarproject.briar.R;
+import org.briarproject.briar.android.activity.ActivityComponent;
+import org.briarproject.briar.android.blog.BlogPostAdapter.OnBlogPostClickListener;
+import org.briarproject.briar.android.blog.FeedController.FeedListener;
+import org.briarproject.briar.android.controller.handler.UiResultExceptionHandler;
+import org.briarproject.briar.android.fragment.BaseFragment;
+import org.briarproject.briar.android.view.BriarRecyclerView;
+import org.briarproject.briar.api.blog.Blog;
+import org.briarproject.briar.api.blog.BlogPostHeader;
+
+import java.util.Collection;
+import java.util.logging.Logger;
+
+import javax.annotation.Nullable;
+import javax.inject.Inject;
+
+import static android.app.Activity.RESULT_OK;
+import static android.support.design.widget.Snackbar.LENGTH_LONG;
+import static android.support.v4.app.ActivityOptionsCompat.makeCustomAnimation;
+import static org.briarproject.briar.android.activity.BriarActivity.GROUP_ID;
+import static org.briarproject.briar.android.blog.BlogActivity.REQUEST_WRITE_POST;
+
+@UiThread
+@MethodsNotNullByDefault
+@ParametersNotNullByDefault
+public class FeedFragment extends BaseFragment implements
+		OnBlogPostClickListener, FeedListener {
+
+	public final static String TAG = FeedFragment.class.getName();
+	private static final Logger LOG = Logger.getLogger(TAG);
+
+	@Inject
+	FeedController feedController;
+
+	private BlogPostAdapter adapter;
+	private LinearLayoutManager layoutManager;
+	private BriarRecyclerView list;
+	private Blog personalBlog = null;
+
+	public static FeedFragment newInstance() {
+		FeedFragment f = new FeedFragment();
+
+		Bundle args = new Bundle();
+		f.setArguments(args);
+
+		return f;
+	}
+
+	@Nullable
+	@Override
+	public View onCreateView(LayoutInflater inflater,
+			@Nullable ViewGroup container,
+			@Nullable Bundle savedInstanceState) {
+
+		View v = inflater.inflate(R.layout.fragment_blog, container, false);
+
+		adapter = new BlogPostAdapter(getActivity(), this);
+
+		layoutManager = new LinearLayoutManager(getActivity());
+		list = (BriarRecyclerView) v.findViewById(R.id.postList);
+		list.setLayoutManager(layoutManager);
+		list.setAdapter(adapter);
+		list.setEmptyText(R.string.blogs_feed_empty_state);
+
+		return v;
+	}
+
+	@Override
+	public void injectFragment(ActivityComponent component) {
+		component.inject(this);
+		feedController.setFeedListener(this);
+	}
+
+	@Override
+	public void onActivityResult(int requestCode, int resultCode, Intent data) {
+		super.onActivityResult(requestCode, resultCode, data);
+
+		// The BlogPostAddedEvent arrives when the controller is not listening
+		if (requestCode == REQUEST_WRITE_POST && resultCode == RESULT_OK) {
+			showSnackBar(R.string.blogs_blog_post_created);
+		}
+	}
+
+	@Override
+	public void onStart() {
+		super.onStart();
+		feedController.onStart();
+		loadPersonalBlog();
+		loadBlogPosts(false);
+	}
+
+	@Override
+	public void onStop() {
+		super.onStop();
+		feedController.onStop();
+		adapter.clear();
+		list.showProgressBar();
+		list.stopPeriodicUpdate();
+		// TODO save list position in database/preferences?
+	}
+
+	private void loadPersonalBlog() {
+		feedController.loadPersonalBlog(
+				new UiResultExceptionHandler<Blog, DbException>(this) {
+					@Override
+					public void onResultUi(Blog b) {
+						personalBlog = b;
+					}
+
+					@Override
+					public void onExceptionUi(DbException exception) {
+						// TODO: Decide how to handle errors in the UI
+					}
+				});
+	}
+
+	private void loadBlogPosts(final boolean clear) {
+		final int revision = adapter.getRevision();
+		feedController.loadBlogPosts(
+				new UiResultExceptionHandler<Collection<BlogPostItem>, DbException>(
+						this) {
+					@Override
+					public void onResultUi(Collection<BlogPostItem> posts) {
+						if (revision == adapter.getRevision()) {
+							adapter.incrementRevision();
+							if (clear) adapter.setItems(posts);
+							else adapter.addAll(posts);
+							if (posts.isEmpty()) list.showData();
+						} else {
+							LOG.info("Concurrent update, reloading");
+							loadBlogPosts(clear);
+						}
+					}
+
+					@Override
+					public void onExceptionUi(DbException e) {
+						// TODO: Decide how to handle errors in the UI
+					}
+				});
+		list.startPeriodicUpdate();
+	}
+
+	@Override
+	public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
+		inflater.inflate(R.menu.blogs_feed_actions, menu);
+		super.onCreateOptionsMenu(menu, inflater);
+	}
+
+	@Override
+	public boolean onOptionsItemSelected(final MenuItem item) {
+		if (personalBlog == null) return false;
+		ActivityOptionsCompat options =
+				makeCustomAnimation(getActivity(), android.R.anim.slide_in_left,
+						android.R.anim.slide_out_right);
+		switch (item.getItemId()) {
+			case R.id.action_write_blog_post:
+				Intent i1 =
+						new Intent(getActivity(), WriteBlogPostActivity.class);
+				i1.putExtra(GROUP_ID, personalBlog.getId().getBytes());
+				startActivityForResult(i1, REQUEST_WRITE_POST,
+						options.toBundle());
+				return true;
+			case R.id.action_rss_feeds_import:
+				Intent i2 =
+						new Intent(getActivity(), RssFeedImportActivity.class);
+				i2.putExtra(GROUP_ID, personalBlog.getId().getBytes());
+				startActivity(i2, options.toBundle());
+				return true;
+			case R.id.action_rss_feeds_manage:
+				Intent i3 =
+						new Intent(getActivity(), RssFeedManageActivity.class);
+				i3.putExtra(GROUP_ID, personalBlog.getId().getBytes());
+				startActivity(i3, options.toBundle());
+				return true;
+			default:
+				return super.onOptionsItemSelected(item);
+		}
+	}
+
+	@Override
+	public void onBlogPostAdded(BlogPostHeader header, final boolean local) {
+		feedController.loadBlogPost(header,
+				new UiResultExceptionHandler<BlogPostItem, DbException>(
+						this) {
+					@Override
+					public void onResultUi(BlogPostItem post) {
+						adapter.incrementRevision();
+						adapter.add(post);
+						if (local) {
+							showSnackBar(R.string.blogs_blog_post_created);
+						} else {
+							showSnackBar(R.string.blogs_blog_post_received);
+						}
+					}
+
+					@Override
+					public void onExceptionUi(DbException exception) {
+						// TODO: Decide how to handle errors in the UI
+					}
+				}
+		);
+	}
+
+	@Override
+	public void onBlogPostClick(BlogPostItem post) {
+		FeedPostFragment f =
+				FeedPostFragment.newInstance(post.getGroupId(), post.getId());
+		getActivity().getSupportFragmentManager().beginTransaction()
+				.replace(R.id.content_fragment, f, f.getUniqueTag())
+				.addToBackStack(f.getUniqueTag())
+				.commit();
+	}
+
+	@Override
+	public String getUniqueTag() {
+		return TAG;
+	}
+
+	private void showSnackBar(int stringRes) {
+		int firstVisible =
+				layoutManager.findFirstCompletelyVisibleItemPosition();
+		int lastVisible = layoutManager.findLastCompletelyVisibleItemPosition();
+		int count = adapter.getItemCount();
+		boolean scroll = count > (lastVisible - firstVisible + 1);
+
+		Snackbar s = Snackbar.make(list, stringRes, LENGTH_LONG);
+		s.getView().setBackgroundResource(R.color.briar_primary);
+		if (scroll) {
+			OnClickListener onClick = new OnClickListener() {
+				@Override
+				public void onClick(View v) {
+					list.smoothScrollToPosition(0);
+				}
+			};
+			s.setActionTextColor(ContextCompat
+					.getColor(getContext(),
+							R.color.briar_button_positive));
+			s.setAction(R.string.blogs_blog_post_scroll_to, onClick);
+		}
+		s.show();
+	}
+
+	@Override
+	public void onBlogAdded() {
+		loadBlogPosts(false);
+	}
+
+	@Override
+	public void onBlogRemoved() {
+		loadBlogPosts(true);
+	}
+}

briar-android/src/main/java/org/briarproject/briar/android/blog/FeedPostFragment.java

@@ -0,0 +1,92 @@
+package org.briarproject.briar.android.blog;
+
+import android.os.Bundle;
+import android.support.annotation.UiThread;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+
+import org.briarproject.bramble.api.db.DbException;
+import org.briarproject.bramble.api.nullsafety.MethodsNotNullByDefault;
+import org.briarproject.bramble.api.nullsafety.ParametersNotNullByDefault;
+import org.briarproject.bramble.api.sync.GroupId;
+import org.briarproject.bramble.api.sync.MessageId;
+import org.briarproject.briar.android.activity.ActivityComponent;
+import org.briarproject.briar.android.controller.handler.UiResultExceptionHandler;
+
+import javax.annotation.Nullable;
+import javax.inject.Inject;
+
+import static org.briarproject.briar.android.activity.BriarActivity.GROUP_ID;
+
+@UiThread
+@MethodsNotNullByDefault
+@ParametersNotNullByDefault
+public class FeedPostFragment extends BasePostFragment {
+
+	private static final String TAG = FeedPostFragment.class.getName();
+
+	private MessageId postId;
+	private GroupId blogId;
+
+	@Inject
+	FeedController feedController;
+
+	static FeedPostFragment newInstance(GroupId blogId, MessageId postId) {
+		FeedPostFragment f = new FeedPostFragment();
+
+		Bundle bundle = new Bundle();
+		bundle.putByteArray(GROUP_ID, blogId.getBytes());
+		bundle.putByteArray(POST_ID, postId.getBytes());
+
+		f.setArguments(bundle);
+		return f;
+	}
+
+	@Nullable
+	@Override
+	public View onCreateView(LayoutInflater inflater,
+			@Nullable ViewGroup container,
+			@Nullable Bundle savedInstanceState) {
+
+		Bundle args = getArguments();
+		byte[] b = args.getByteArray(GROUP_ID);
+		if (b == null) throw new IllegalStateException("No group ID in args");
+		blogId = new GroupId(b);
+
+		byte[] p = args.getByteArray(POST_ID);
+		if (p == null) throw new IllegalStateException("No post ID in args");
+		postId = new MessageId(p);
+
+		return super.onCreateView(inflater, container, savedInstanceState);
+	}
+
+	@Override
+	public String getUniqueTag() {
+		return TAG;
+	}
+
+	@Override
+	public void injectFragment(ActivityComponent component) {
+		component.inject(this);
+	}
+
+	@Override
+	public void onStart() {
+		super.onStart();
+		feedController.loadBlogPost(blogId, postId,
+				new UiResultExceptionHandler<BlogPostItem, DbException>(
+						this) {
+					@Override
+					public void onResultUi(BlogPostItem post) {
+						onBlogPostLoaded(post);
+					}
+
+					@Override
+					public void onExceptionUi(DbException exception) {
+						// TODO: Decide how to handle errors in the UI
+					}
+				});
+	}
+
+}

briar-android/src/main/java/org/briarproject/briar/android/blog/ReblogActivity.java

@@ -0,0 +1,81 @@
+package org.briarproject.briar.android.blog;
+
+import android.annotation.TargetApi;
+import android.content.Intent;
+import android.os.Build;
+import android.os.Bundle;
+import android.transition.Fade;
+import android.transition.Transition;
+import android.view.MenuItem;
+
+import org.briarproject.bramble.api.sync.GroupId;
+import org.briarproject.bramble.api.sync.MessageId;
+import org.briarproject.briar.R;
+import org.briarproject.briar.android.activity.ActivityComponent;
+import org.briarproject.briar.android.activity.BriarActivity;
+import org.briarproject.briar.android.fragment.BaseFragment.BaseFragmentListener;
+
+import static org.briarproject.briar.android.blog.BasePostFragment.POST_ID;
+
+public class ReblogActivity extends BriarActivity implements
+		BaseFragmentListener {
+
+	@Override
+	public void onCreate(Bundle savedInstanceState) {
+		super.onCreate(savedInstanceState);
+
+		if (Build.VERSION.SDK_INT >= 21) {
+			setTransition();
+		}
+
+		Intent intent = getIntent();
+		byte[] groupId = intent.getByteArrayExtra(GROUP_ID);
+		if (groupId == null)
+			throw new IllegalArgumentException("No group ID in intent");
+		byte[] postId = intent.getByteArrayExtra(POST_ID);
+		if (postId == null)
+			throw new IllegalArgumentException("No post message ID in intent");
+
+		setContentView(R.layout.activity_fragment_container);
+
+		if (savedInstanceState == null) {
+			ReblogFragment f = ReblogFragment
+					.newInstance(new GroupId(groupId), new MessageId(postId));
+			getSupportFragmentManager()
+					.beginTransaction()
+					.add(R.id.fragmentContainer, f)
+					.commit();
+		}
+	}
+
+	@Override
+	public boolean onOptionsItemSelected(MenuItem item) {
+		switch (item.getItemId()) {
+			case android.R.id.home:
+				onBackPressed();
+				return true;
+			default:
+				return super.onOptionsItemSelected(item);
+		}
+	}
+
+	@Override
+	public void injectActivity(ActivityComponent component) {
+		component.inject(this);
+	}
+
+	@Override
+	public void onFragmentCreated(String tag) {
+
+	}
+
+	@TargetApi(21)
+	private void setTransition() {
+		Transition fade = new Fade();
+		fade.excludeTarget(android.R.id.statusBarBackground, true);
+		fade.excludeTarget(R.id.action_bar_container, true);
+		fade.excludeTarget(android.R.id.navigationBarBackground, true);
+		getWindow().setExitTransition(fade);
+		getWindow().setEnterTransition(fade);
+	}
+}

briar-android/src/main/java/org/briarproject/briar/android/blog/ReblogFragment.java

@@ -0,0 +1,171 @@
+package org.briarproject.briar.android.blog;
+
+import android.os.Bundle;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.ProgressBar;
+import android.widget.ScrollView;
+
+import org.briarproject.bramble.api.db.DbException;
+import org.briarproject.bramble.api.nullsafety.MethodsNotNullByDefault;
+import org.briarproject.bramble.api.nullsafety.ParametersNotNullByDefault;
+import org.briarproject.bramble.api.sync.GroupId;
+import org.briarproject.bramble.api.sync.MessageId;
+import org.briarproject.briar.R;
+import org.briarproject.briar.android.activity.ActivityComponent;
+import org.briarproject.briar.android.controller.handler.UiExceptionHandler;
+import org.briarproject.briar.android.controller.handler.UiResultExceptionHandler;
+import org.briarproject.briar.android.fragment.BaseFragment;
+import org.briarproject.briar.android.view.TextInputView;
+import org.briarproject.briar.android.view.TextInputView.TextInputListener;
+
+import javax.annotation.Nullable;
+import javax.inject.Inject;
+
+import static android.view.View.FOCUS_DOWN;
+import static android.view.View.GONE;
+import static android.view.View.INVISIBLE;
+import static android.view.View.VISIBLE;
+import static org.briarproject.briar.android.activity.BriarActivity.GROUP_ID;
+import static org.briarproject.briar.android.blog.BasePostFragment.POST_ID;
+
+@MethodsNotNullByDefault
+@ParametersNotNullByDefault
+public class ReblogFragment extends BaseFragment implements TextInputListener {
+
+	public static final String TAG = ReblogFragment.class.getName();
+
+	private ViewHolder ui;
+	private GroupId blogId;
+	private MessageId postId;
+	private BlogPostItem item;
+
+	@Inject
+	FeedController feedController;
+
+	static ReblogFragment newInstance(GroupId groupId, MessageId messageId) {
+		ReblogFragment f = new ReblogFragment();
+
+		Bundle args = new Bundle();
+		args.putByteArray(GROUP_ID, groupId.getBytes());
+		args.putByteArray(POST_ID, messageId.getBytes());
+		f.setArguments(args);
+
+		return f;
+	}
+
+	@Override
+	public String getUniqueTag() {
+		return TAG;
+	}
+
+	@Override
+	public void injectFragment(ActivityComponent component) {
+		component.inject(this);
+	}
+
+	@Override
+	public View onCreateView(LayoutInflater inflater,
+			@Nullable ViewGroup container,
+			@Nullable Bundle savedInstanceState) {
+
+		Bundle args = getArguments();
+		blogId = new GroupId(args.getByteArray(GROUP_ID));
+		postId = new MessageId(args.getByteArray(POST_ID));
+
+		View v = inflater.inflate(R.layout.fragment_reblog, container,
+				false);
+		ui = new ViewHolder(v);
+		ui.post.setTransitionName(postId);
+		ui.input.setSendButtonEnabled(false);
+		showProgressBar();
+
+		return v;
+	}
+
+	@Override
+	public void onStart() {
+		super.onStart();
+
+		// TODO: Load blog post when fragment is created. #631
+		feedController.loadBlogPost(blogId, postId,
+				new UiResultExceptionHandler<BlogPostItem, DbException>(
+						this) {
+					@Override
+					public void onResultUi(BlogPostItem result) {
+						item = result;
+						bindViewHolder();
+					}
+
+					@Override
+					public void onExceptionUi(DbException exception) {
+						// TODO
+						finish();
+					}
+				});
+	}
+
+	private void bindViewHolder() {
+		if (item == null) return;
+
+		hideProgressBar();
+
+		ui.post.bindItem(item);
+		ui.post.hideReblogButton();
+
+		ui.input.setListener(this);
+		ui.input.setSendButtonEnabled(true);
+		ui.scrollView.post(new Runnable() {
+			@Override
+			public void run() {
+				ui.scrollView.fullScroll(FOCUS_DOWN);
+			}
+		});
+	}
+
+	@Override
+	public void onSendClick(String text) {
+		String comment = getComment();
+		feedController.repeatPost(item, comment,
+				new UiExceptionHandler<DbException>(this) {
+					@Override
+					public void onExceptionUi(DbException exception) {
+						// TODO proper error handling
+						// do nothing, this fragment is gone already
+					}
+				});
+		finish();
+	}
+
+	@Nullable
+	private String getComment() {
+		if (ui.input.getText().length() == 0) return null;
+		return ui.input.getText().toString();
+	}
+
+	private void showProgressBar() {
+		ui.progressBar.setVisibility(VISIBLE);
+		ui.input.setVisibility(GONE);
+	}
+
+	private void hideProgressBar() {
+		ui.progressBar.setVisibility(INVISIBLE);
+		ui.input.setVisibility(VISIBLE);
+	}
+
+	private static class ViewHolder {
+
+		private final ScrollView scrollView;
+		private final ProgressBar progressBar;
+		private final BlogPostViewHolder post;
+		private final TextInputView input;
+
+		private ViewHolder(View v) {
+			scrollView = (ScrollView) v.findViewById(R.id.scrollView);
+			progressBar = (ProgressBar) v.findViewById(R.id.progressBar);
+			post = new BlogPostViewHolder(v.findViewById(R.id.postLayout));
+			input = (TextInputView) v.findViewById(R.id.inputText);
+		}
+	}
+}

briar-android/src/main/java/org/briarproject/briar/android/blog/RssFeedAdapter.java

@@ -0,0 +1,127 @@
+package org.briarproject.briar.android.blog;
+
+import android.content.Context;
+import android.support.v7.widget.RecyclerView;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.view.ViewGroup;
+import android.widget.ImageView;
+import android.widget.TextView;
+
+import org.briarproject.briar.R;
+import org.briarproject.briar.android.util.BriarAdapter;
+import org.briarproject.briar.android.util.UiUtils;
+import org.briarproject.briar.api.feed.Feed;
+
+import static android.view.View.GONE;
+import static android.view.View.VISIBLE;
+
+class RssFeedAdapter extends BriarAdapter<Feed, RssFeedAdapter.FeedViewHolder> {
+
+	private final RssFeedListener listener;
+
+	RssFeedAdapter(Context ctx, RssFeedListener listener) {
+		super(ctx, Feed.class);
+		this.listener = listener;
+	}
+
+	@Override
+	public FeedViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
+		View v = LayoutInflater.from(ctx).inflate(
+				R.layout.list_item_rss_feed, parent, false);
+		return new FeedViewHolder(v);
+	}
+
+	@Override
+	public void onBindViewHolder(FeedViewHolder ui, int position) {
+		final Feed item = getItemAt(position);
+		if (item == null) return;
+
+		// Feed Title
+		if (item.getTitle() != null) {
+			ui.title.setText(item.getTitle());
+			ui.title.setVisibility(VISIBLE);
+		} else {
+			ui.title.setVisibility(GONE);
+		}
+
+		// Delete Button
+		ui.delete.setOnClickListener(new OnClickListener() {
+			@Override
+			public void onClick(View v) {
+				listener.onDeleteClick(item);
+			}
+		});
+
+		// Author
+		if (item.getAuthor() != null) {
+			ui.author.setText(item.getAuthor());
+			ui.author.setVisibility(VISIBLE);
+			ui.authorLabel.setVisibility(VISIBLE);
+		} else {
+			ui.author.setVisibility(GONE);
+			ui.authorLabel.setVisibility(GONE);
+		}
+
+		// Imported and Last Updated
+		ui.imported.setText(UiUtils.formatDate(ctx, item.getAdded()));
+		ui.updated.setText(UiUtils.formatDate(ctx, item.getUpdated()));
+
+		// Description
+		if (item.getDescription() != null) {
+			ui.description.setText(item.getDescription());
+			ui.description.setVisibility(VISIBLE);
+		} else {
+			ui.description.setVisibility(GONE);
+		}
+	}
+
+	@Override
+	public int compare(Feed a, Feed b) {
+		if (a == b) return 0;
+		long aTime = a.getAdded(), bTime = b.getAdded();
+		if (aTime > bTime) return -1;
+		if (aTime < bTime) return 1;
+		return 0;
+	}
+
+	@Override
+	public boolean areContentsTheSame(Feed a, Feed b) {
+		return a.getUpdated() == b.getUpdated();
+	}
+
+	@Override
+	public boolean areItemsTheSame(Feed a, Feed b) {
+		return a.getUrl().equals(b.getUrl()) &&
+				a.getBlogId().equals(b.getBlogId()) &&
+				a.getAdded() == b.getAdded();
+	}
+
+	static class FeedViewHolder extends RecyclerView.ViewHolder {
+		private final TextView title;
+		private final ImageView delete;
+		private final TextView imported;
+		private final TextView updated;
+		private final TextView author;
+		private final TextView authorLabel;
+		private final TextView description;
+
+		private FeedViewHolder(View v) {
+			super(v);
+
+			title = (TextView) v.findViewById(R.id.titleView);
+			delete = (ImageView) v.findViewById(R.id.deleteButton);
+			imported = (TextView) v.findViewById(R.id.importedView);
+			updated = (TextView) v.findViewById(R.id.updatedView);
+			author = (TextView) v.findViewById(R.id.authorView);
+			authorLabel = (TextView) v.findViewById(R.id.author);
+			description = (TextView) v.findViewById(R.id.descriptionView);
+		}
+	}
+
+	interface RssFeedListener {
+		void onDeleteClick(Feed feed);
+	}
+
+}

briar-android/src/main/java/org/briarproject/briar/android/blog/RssFeedImportActivity.java

@@ -0,0 +1,179 @@
+package org.briarproject.briar.android.blog;
+
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.os.Bundle;
+import android.support.v7.app.AlertDialog;
+import android.text.Editable;
+import android.text.TextWatcher;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.View;
+import android.widget.Button;
+import android.widget.EditText;
+import android.widget.ProgressBar;
+
+import org.briarproject.bramble.api.db.DbException;
+import org.briarproject.bramble.api.lifecycle.IoExecutor;
+import org.briarproject.bramble.api.sync.GroupId;
+import org.briarproject.briar.R;
+import org.briarproject.briar.android.activity.ActivityComponent;
+import org.briarproject.briar.android.activity.BriarActivity;
+import org.briarproject.briar.api.feed.FeedManager;
+
+import java.io.IOException;
+import java.util.concurrent.Executor;
+import java.util.logging.Logger;
+
+import javax.inject.Inject;
+
+import static android.view.View.GONE;
+import static android.view.View.VISIBLE;
+import static java.util.logging.Level.WARNING;
+
+public class RssFeedImportActivity extends BriarActivity {
+
+	private static final Logger LOG =
+			Logger.getLogger(RssFeedImportActivity.class.getName());
+
+	private EditText urlInput;
+	private Button importButton;
+	private ProgressBar progressBar;
+
+	@Inject
+	@IoExecutor
+	Executor ioExecutor;
+
+	// Fields that are accessed from background threads must be volatile
+	private volatile GroupId groupId = null;
+
+	@Inject
+	@SuppressWarnings("WeakerAccess")
+	volatile FeedManager feedManager;
+
+	@Override
+	public void onCreate(Bundle savedInstanceState) {
+		super.onCreate(savedInstanceState);
+
+		// GroupId from Intent
+		Intent i = getIntent();
+		byte[] b = i.getByteArrayExtra(GROUP_ID);
+		if (b == null) throw new IllegalStateException("No Group in intent.");
+		groupId = new GroupId(b);
+
+		setContentView(R.layout.activity_rss_feed_import);
+
+		urlInput = (EditText) findViewById(R.id.urlInput);
+		urlInput.addTextChangedListener(new TextWatcher() {
+			@Override
+			public void beforeTextChanged(CharSequence s, int start, int count,
+					int after) {
+			}
+
+			@Override
+			public void onTextChanged(CharSequence s, int start, int before,
+					int count) {
+			}
+
+			@Override
+			public void afterTextChanged(Editable s) {
+				enableOrDisableImportButton();
+			}
+		});
+
+		importButton = (Button) findViewById(R.id.importButton);
+		importButton.setOnClickListener(new View.OnClickListener() {
+			@Override
+			public void onClick(View v) {
+				publish();
+			}
+		});
+
+		progressBar = (ProgressBar) findViewById(R.id.progressBar);
+	}
+
+	@Override
+	public boolean onCreateOptionsMenu(Menu menu) {
+		return super.onCreateOptionsMenu(menu);
+	}
+
+	@Override
+	public boolean onOptionsItemSelected(MenuItem item) {
+		return super.onOptionsItemSelected(item);
+	}
+
+	@Override
+	public void injectActivity(ActivityComponent component) {
+		component.inject(this);
+	}
+
+	private void enableOrDisableImportButton() {
+		String url = urlInput.getText().toString();
+		if (url.startsWith("http://") || url.startsWith("https://"))
+			importButton.setEnabled(true);
+		else
+			importButton.setEnabled(false);
+	}
+
+	private void publish() {
+		// hide import button, show progress bar
+		importButton.setVisibility(GONE);
+		progressBar.setVisibility(VISIBLE);
+
+		importFeed(urlInput.getText().toString());
+	}
+
+	private void importFeed(final String url) {
+		ioExecutor.execute(new Runnable() {
+			@Override
+			public void run() {
+				try {
+					feedManager.addFeed(url, groupId);
+					feedImported();
+				} catch (DbException | IOException e) {
+					if (LOG.isLoggable(WARNING))
+						LOG.log(WARNING, e.toString(), e);
+					importFailed();
+				}
+			}
+		});
+	}
+
+	private void feedImported() {
+		runOnUiThreadUnlessDestroyed(new Runnable() {
+			@Override
+			public void run() {
+				supportFinishAfterTransition();
+			}
+		});
+	}
+
+	private void importFailed() {
+		runOnUiThreadUnlessDestroyed(new Runnable() {
+			@Override
+			public void run() {
+				// hide progress bar, show publish button
+				progressBar.setVisibility(GONE);
+				importButton.setVisibility(VISIBLE);
+
+				// show error dialog
+				AlertDialog.Builder builder =
+						new AlertDialog.Builder(RssFeedImportActivity.this,
+								R.style.BriarDialogTheme);
+				builder.setMessage(R.string.blogs_rss_feeds_import_error);
+				builder.setNegativeButton(R.string.cancel, null);
+				builder.setPositiveButton(R.string.try_again_button,
+						new DialogInterface.OnClickListener() {
+							@Override
+							public void onClick(DialogInterface dialog, int which) {
+								publish();
+							}
+						});
+				AlertDialog dialog = builder.create();
+				dialog.show();
+			}
+		});
+	}
+
+}
+

briar-android/src/main/java/org/briarproject/briar/android/blog/RssFeedManageActivity.java

@@ -0,0 +1,190 @@
+package org.briarproject.briar.android.blog;
+
+import android.content.Intent;
+import android.os.Bundle;
+import android.support.design.widget.Snackbar;
+import android.support.v4.app.ActivityCompat;
+import android.support.v4.app.ActivityOptionsCompat;
+import android.support.v7.widget.LinearLayoutManager;
+import android.view.Menu;
+import android.view.MenuInflater;
+import android.view.MenuItem;
+
+import org.briarproject.bramble.api.db.DbException;
+import org.briarproject.bramble.api.sync.GroupId;
+import org.briarproject.briar.R;
+import org.briarproject.briar.android.activity.ActivityComponent;
+import org.briarproject.briar.android.activity.BriarActivity;
+import org.briarproject.briar.android.blog.RssFeedAdapter.RssFeedListener;
+import org.briarproject.briar.android.view.BriarRecyclerView;
+import org.briarproject.briar.api.feed.Feed;
+import org.briarproject.briar.api.feed.FeedManager;
+
+import java.util.List;
+import java.util.logging.Logger;
+
+import javax.inject.Inject;
+
+import static android.support.design.widget.Snackbar.LENGTH_LONG;
+import static android.support.v4.app.ActivityOptionsCompat.makeCustomAnimation;
+import static java.util.logging.Level.WARNING;
+
+public class RssFeedManageActivity extends BriarActivity
+		implements RssFeedListener {
+
+	private static final Logger LOG =
+			Logger.getLogger(RssFeedManageActivity.class.getName());
+
+	private BriarRecyclerView list;
+	private RssFeedAdapter adapter;
+	private GroupId groupId;
+
+	@Inject
+	@SuppressWarnings("WeakerAccess")
+	volatile FeedManager feedManager;
+
+	@Override
+	public void onCreate(Bundle savedInstanceState) {
+		super.onCreate(savedInstanceState);
+
+		// GroupId from Intent
+		Intent i = getIntent();
+		byte[] b = i.getByteArrayExtra(GROUP_ID);
+		if (b == null) throw new IllegalStateException("No Group in intent.");
+		groupId = new GroupId(b);
+
+		setContentView(R.layout.activity_rss_feed_manage);
+
+		adapter = new RssFeedAdapter(this, this);
+
+		list = (BriarRecyclerView) findViewById(R.id.feedList);
+		list.setLayoutManager(new LinearLayoutManager(this));
+		list.setAdapter(adapter);
+	}
+
+	@Override
+	public void onStart() {
+		super.onStart();
+		loadFeeds();
+	}
+
+	@Override
+	public void onStop() {
+		super.onStop();
+		adapter.clear();
+		list.showProgressBar();
+	}
+
+	@Override
+	public boolean onCreateOptionsMenu(Menu menu) {
+		MenuInflater inflater = getMenuInflater();
+		inflater.inflate(R.menu.rss_feed_manage_actions, menu);
+		return super.onCreateOptionsMenu(menu);
+	}
+
+	@Override
+	public boolean onOptionsItemSelected(MenuItem item) {
+		switch (item.getItemId()) {
+			case android.R.id.home:
+				onBackPressed();
+				return true;
+			case R.id.action_rss_feeds_import:
+				Intent i =
+						new Intent(this, RssFeedImportActivity.class);
+				i.putExtra(GROUP_ID, groupId.getBytes());
+				ActivityOptionsCompat options =
+						makeCustomAnimation(this, android.R.anim.slide_in_left,
+								android.R.anim.slide_out_right);
+				ActivityCompat.startActivity(this, i, options.toBundle());
+				return true;
+			default:
+				return super.onOptionsItemSelected(item);
+		}
+	}
+
+	@Override
+	public void injectActivity(ActivityComponent component) {
+		component.inject(this);
+	}
+
+	@Override
+	public void onDeleteClick(final Feed feed) {
+		runOnDbThread(new Runnable() {
+			@Override
+			public void run() {
+				try {
+					feedManager.removeFeed(feed.getUrl());
+					onFeedDeleted(feed);
+				} catch (DbException e) {
+					if (LOG.isLoggable(WARNING))
+						LOG.log(WARNING, e.toString(), e);
+					onDeleteError();
+				}
+			}
+		});
+	}
+
+	private void loadFeeds() {
+		final int revision = adapter.getRevision();
+		runOnDbThread(new Runnable() {
+			@Override
+			public void run() {
+				try {
+					displayFeeds(revision, feedManager.getFeeds());
+				} catch (DbException e) {
+					if (LOG.isLoggable(WARNING))
+						LOG.log(WARNING, e.toString(), e);
+					onLoadError();
+				}
+			}
+		});
+	}
+
+	private void displayFeeds(final int revision, final List<Feed> feeds) {
+		runOnUiThreadUnlessDestroyed(new Runnable() {
+			@Override
+			public void run() {
+				if (revision == adapter.getRevision()) {
+					adapter.incrementRevision();
+					if (feeds.isEmpty()) list.showData();
+					else adapter.addAll(feeds);
+				} else {
+					LOG.info("Concurrent update, reloading");
+					loadFeeds();
+				}
+			}
+		});
+	}
+
+	private void onLoadError() {
+		runOnUiThreadUnlessDestroyed(new Runnable() {
+			@Override
+			public void run() {
+				list.setEmptyText(R.string.blogs_rss_feeds_manage_error);
+				list.showData();
+			}
+		});
+	}
+
+	private void onFeedDeleted(final Feed feed) {
+		runOnUiThreadUnlessDestroyed(new Runnable() {
+			@Override
+			public void run() {
+				adapter.incrementRevision();
+				adapter.remove(feed);
+			}
+		});
+	}
+
+	private void onDeleteError() {
+		runOnUiThreadUnlessDestroyed(new Runnable() {
+			@Override
+			public void run() {
+				Snackbar.make(list,
+						R.string.blogs_rss_feeds_manage_delete_error,
+						LENGTH_LONG).show();
+			}
+		});
+	}
+}
+

briar-android/src/main/java/org/briarproject/briar/android/blog/WriteBlogPostActivity.java

@@ -0,0 +1,184 @@
+package org.briarproject.briar.android.blog;
+
+import android.content.Intent;
+import android.os.Bundle;
+import android.text.Editable;
+import android.text.TextWatcher;
+import android.view.KeyEvent;
+import android.view.MenuItem;
+import android.widget.ProgressBar;
+import android.widget.TextView;
+import android.widget.TextView.OnEditorActionListener;
+
+import org.briarproject.bramble.api.FormatException;
+import org.briarproject.bramble.api.db.DbException;
+import org.briarproject.bramble.api.identity.IdentityManager;
+import org.briarproject.bramble.api.identity.LocalAuthor;
+import org.briarproject.bramble.api.sync.GroupId;
+import org.briarproject.bramble.util.StringUtils;
+import org.briarproject.briar.R;
+import org.briarproject.briar.android.activity.ActivityComponent;
+import org.briarproject.briar.android.activity.BriarActivity;
+import org.briarproject.briar.android.view.TextInputView;
+import org.briarproject.briar.android.view.TextInputView.TextInputListener;
+import org.briarproject.briar.api.android.AndroidNotificationManager;
+import org.briarproject.briar.api.blog.BlogManager;
+import org.briarproject.briar.api.blog.BlogPost;
+import org.briarproject.briar.api.blog.BlogPostFactory;
+
+import java.security.GeneralSecurityException;
+import java.util.logging.Logger;
+
+import javax.inject.Inject;
+
+import static android.view.View.GONE;
+import static android.view.View.VISIBLE;
+import static java.util.logging.Level.WARNING;
+import static org.briarproject.briar.api.blog.BlogConstants.MAX_BLOG_POST_BODY_LENGTH;
+
+public class WriteBlogPostActivity extends BriarActivity
+		implements OnEditorActionListener, TextInputListener {
+
+	private static final Logger LOG =
+			Logger.getLogger(WriteBlogPostActivity.class.getName());
+
+	@Inject
+	AndroidNotificationManager notificationManager;
+
+	private TextInputView input;
+	private ProgressBar progressBar;
+
+	// Fields that are accessed from background threads must be volatile
+	private volatile GroupId groupId;
+	@Inject
+	volatile IdentityManager identityManager;
+	@Inject
+	volatile BlogPostFactory blogPostFactory;
+	@Inject
+	volatile BlogManager blogManager;
+
+	@SuppressWarnings("ConstantConditions")
+	@Override
+	public void onCreate(Bundle state) {
+		super.onCreate(state);
+
+		Intent i = getIntent();
+		byte[] b = i.getByteArrayExtra(GROUP_ID);
+		if (b == null) throw new IllegalStateException("No Group in intent.");
+		groupId = new GroupId(b);
+
+		setContentView(R.layout.activity_write_blog_post);
+
+		input = (TextInputView) findViewById(R.id.bodyInput);
+		input.setSendButtonEnabled(false);
+		input.addTextChangedListener(new TextWatcher() {
+			@Override
+			public void beforeTextChanged(CharSequence s, int start, int count,
+					int after) {
+			}
+
+			@Override
+			public void onTextChanged(CharSequence s, int start, int before,
+					int count) {
+			}
+
+			@Override
+			public void afterTextChanged(Editable s) {
+				enableOrDisablePublishButton();
+			}
+		});
+		input.setListener(this);
+
+		progressBar = (ProgressBar) findViewById(R.id.progressBar);
+	}
+
+	@Override
+	public void onStart() {
+		super.onStart();
+		notificationManager.blockNotification(groupId);
+	}
+
+	@Override
+	public void onStop() {
+		super.onStop();
+		notificationManager.unblockNotification(groupId);
+	}
+
+	@Override
+	public boolean onOptionsItemSelected(MenuItem item) {
+		switch (item.getItemId()) {
+			case android.R.id.home:
+				onBackPressed();
+				return true;
+			default:
+				return super.onOptionsItemSelected(item);
+		}
+	}
+
+	@Override
+	public void injectActivity(ActivityComponent component) {
+		component.inject(this);
+	}
+
+	@Override
+	public boolean onEditorAction(TextView textView, int actionId, KeyEvent e) {
+		input.requestFocus();
+		return true;
+	}
+
+	private void enableOrDisablePublishButton() {
+		input.setSendButtonEnabled(input.getText().length() > 0);
+	}
+
+	@Override
+	public void onSendClick(String body) {
+		// hide publish button, show progress bar
+		input.setVisibility(GONE);
+		progressBar.setVisibility(VISIBLE);
+
+		body = StringUtils.truncateUtf8(body, MAX_BLOG_POST_BODY_LENGTH);
+		storePost(body);
+	}
+
+	private void storePost(final String body) {
+		runOnDbThread(new Runnable() {
+			@Override
+			public void run() {
+				long now = System.currentTimeMillis();
+				try {
+					LocalAuthor author = identityManager.getLocalAuthor();
+					BlogPost p = blogPostFactory
+							.createBlogPost(groupId, now, null, author, body);
+					blogManager.addLocalPost(p);
+					postPublished();
+				} catch (DbException | GeneralSecurityException | FormatException e) {
+					if (LOG.isLoggable(WARNING))
+						LOG.log(WARNING, e.toString(), e);
+					postFailedToPublish();
+				}
+			}
+		});
+	}
+
+	private void postPublished() {
+		runOnUiThreadUnlessDestroyed(new Runnable() {
+			@Override
+			public void run() {
+				setResult(RESULT_OK);
+				supportFinishAfterTransition();
+			}
+		});
+	}
+
+	private void postFailedToPublish() {
+		runOnUiThreadUnlessDestroyed(new Runnable() {
+			@Override
+			public void run() {
+				// hide progress bar, show publish button
+				progressBar.setVisibility(GONE);
+				input.setVisibility(VISIBLE);
+				// TODO show error
+			}
+		});
+	}
+}

briar-android/src/main/java/org/briarproject/briar/android/contact/BaseContactListAdapter.java

@@ -0,0 +1,61 @@
+package org.briarproject.briar.android.contact;
+
+import android.content.Context;
+import android.view.View;
+
+import org.briarproject.bramble.api.contact.ContactId;
+import org.briarproject.briar.android.util.BriarAdapter;
+
+import javax.annotation.Nullable;
+
+import static android.support.v7.util.SortedList.INVALID_POSITION;
+
+public abstract class BaseContactListAdapter<I extends ContactItem, VH extends ContactItemViewHolder<I>>
+		extends BriarAdapter<I, VH> {
+
+	@Nullable
+	protected final OnContactClickListener<I> listener;
+
+	public BaseContactListAdapter(Context ctx, Class<I> c,
+			@Nullable OnContactClickListener<I> listener) {
+		super(ctx, c);
+		this.listener = listener;
+	}
+
+	@Override
+	public void onBindViewHolder(final VH ui, int position) {
+		I item = items.get(position);
+		ui.bind(item, listener);
+	}
+
+	@Override
+	public int compare(I c1, I c2) {
+		return c1.getContact().getAuthor().getName()
+				.compareTo(c2.getContact().getAuthor().getName());
+	}
+
+	@Override
+	public boolean areItemsTheSame(I c1, I c2) {
+		return c1.getContact().getId().equals(c2.getContact().getId());
+	}
+
+	@Override
+	public boolean areContentsTheSame(ContactItem c1, ContactItem c2) {
+		return true;
+	}
+
+	int findItemPosition(ContactId c) {
+		int count = getItemCount();
+		for (int i = 0; i < count; i++) {
+			I item = getItemAt(i);
+			if (item != null && item.getContact().getId().equals(c))
+				return i;
+		}
+		return INVALID_POSITION; // Not found
+	}
+
+	public interface OnContactClickListener<I> {
+		void onItemClick(View view, I item);
+	}
+
+}

briar-android/src/main/java/org/briarproject/briar/android/contact/ContactItem.java

@@ -0,0 +1,22 @@
+package org.briarproject.briar.android.contact;
+
+import org.briarproject.bramble.api.contact.Contact;
+import org.briarproject.bramble.api.nullsafety.NotNullByDefault;
+
+import javax.annotation.concurrent.NotThreadSafe;
+
+@NotThreadSafe
+@NotNullByDefault
+public class ContactItem {
+
+	private final Contact contact;
+
+	public ContactItem(Contact contact) {
+		this.contact = contact;
+	}
+
+	public Contact getContact() {
+		return contact;
+	}
+
+}

briar-android/src/main/java/org/briarproject/briar/android/contact/ContactItemViewHolder.java

@@ -0,0 +1,52 @@
+package org.briarproject.briar.android.contact;
+
+import android.support.annotation.UiThread;
+import android.support.v7.widget.RecyclerView;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.ImageView;
+import android.widget.TextView;
+
+import org.briarproject.bramble.api.identity.Author;
+import org.briarproject.bramble.api.nullsafety.NotNullByDefault;
+import org.briarproject.briar.R;
+import org.briarproject.briar.android.contact.BaseContactListAdapter.OnContactClickListener;
+
+import javax.annotation.Nullable;
+
+import im.delight.android.identicons.IdenticonDrawable;
+
+@UiThread
+@NotNullByDefault
+public class ContactItemViewHolder<I extends ContactItem>
+		extends RecyclerView.ViewHolder {
+
+	protected final ViewGroup layout;
+	protected final ImageView avatar;
+	protected final TextView name;
+
+	public ContactItemViewHolder(View v) {
+		super(v);
+
+		layout = (ViewGroup) v;
+		avatar = (ImageView) v.findViewById(R.id.avatarView);
+		name = (TextView) v.findViewById(R.id.nameView);
+	}
+
+	protected void bind(final I item,
+			@Nullable final OnContactClickListener<I> listener) {
+		Author author = item.getContact().getAuthor();
+		avatar.setImageDrawable(
+				new IdenticonDrawable(author.getId().getBytes()));
+		String contactName = author.getName();
+		name.setText(contactName);
+
+		layout.setOnClickListener(new View.OnClickListener() {
+			@Override
+			public void onClick(View v) {
+				if (listener != null) listener.onItemClick(avatar, item);
+			}
+		});
+	}
+
+}

briar-android/src/main/java/org/briarproject/briar/android/contact/ContactListAdapter.java

@@ -0,0 +1,49 @@
+package org.briarproject.briar.android.contact;
+
+import android.content.Context;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+
+import org.briarproject.briar.R;
+
+public class ContactListAdapter extends
+		BaseContactListAdapter<ContactListItem, ContactListItemViewHolder> {
+
+	public ContactListAdapter(Context context,
+			OnContactClickListener<ContactListItem> listener) {
+		super(context, ContactListItem.class, listener);
+	}
+
+	@Override
+	public ContactListItemViewHolder onCreateViewHolder(ViewGroup viewGroup,
+			int i) {
+		View v = LayoutInflater.from(viewGroup.getContext()).inflate(
+				R.layout.list_item_contact, viewGroup, false);
+
+		return new ContactListItemViewHolder(v);
+	}
+
+	@Override
+	public boolean areContentsTheSame(ContactListItem c1, ContactListItem c2) {
+		// check for all properties that influence visual
+		// representation of contact
+		if (c1.getUnreadCount() != c2.getUnreadCount()) {
+			return false;
+		}
+		if (c1.getTimestamp() != c2.getTimestamp()) {
+			return false;
+		}
+		return c1.isConnected() == c2.isConnected();
+	}
+
+	@Override
+	public int compare(ContactListItem c1, ContactListItem c2) {
+		long time1 = c1.getTimestamp();
+		long time2 = c2.getTimestamp();
+		if (time1 < time2) return 1;
+		if (time1 > time2) return -1;
+		return 0;
+	}
+
+}

briar-android/src/main/java/org/briarproject/briar/android/contact/ContactListFragment.java

@@ -0,0 +1,339 @@
+package org.briarproject.briar.android.contact;
+
+import android.content.Intent;
+import android.os.Build;
+import android.os.Bundle;
+import android.support.v4.app.ActivityCompat;
+import android.support.v4.app.ActivityOptionsCompat;
+import android.support.v4.util.Pair;
+import android.support.v7.widget.LinearLayoutManager;
+import android.view.LayoutInflater;
+import android.view.Menu;
+import android.view.MenuInflater;
+import android.view.MenuItem;
+import android.view.View;
+import android.view.ViewGroup;
+
+import org.briarproject.bramble.api.contact.Contact;
+import org.briarproject.bramble.api.contact.ContactId;
+import org.briarproject.bramble.api.contact.ContactManager;
+import org.briarproject.bramble.api.contact.event.ContactRemovedEvent;
+import org.briarproject.bramble.api.contact.event.ContactStatusChangedEvent;
+import org.briarproject.bramble.api.db.DbException;
+import org.briarproject.bramble.api.db.NoSuchContactException;
+import org.briarproject.bramble.api.event.Event;
+import org.briarproject.bramble.api.event.EventBus;
+import org.briarproject.bramble.api.event.EventListener;
+import org.briarproject.bramble.api.nullsafety.MethodsNotNullByDefault;
+import org.briarproject.bramble.api.nullsafety.ParametersNotNullByDefault;
+import org.briarproject.bramble.api.plugin.ConnectionRegistry;
+import org.briarproject.bramble.api.plugin.event.ContactConnectedEvent;
+import org.briarproject.bramble.api.plugin.event.ContactDisconnectedEvent;
+import org.briarproject.briar.R;
+import org.briarproject.briar.android.activity.ActivityComponent;
+import org.briarproject.briar.android.contact.BaseContactListAdapter.OnContactClickListener;
+import org.briarproject.briar.android.fragment.BaseFragment;
+import org.briarproject.briar.android.keyagreement.KeyAgreementActivity;
+import org.briarproject.briar.android.view.BriarRecyclerView;
+import org.briarproject.briar.api.android.AndroidNotificationManager;
+import org.briarproject.briar.api.client.BaseMessageHeader;
+import org.briarproject.briar.api.client.MessageTracker.GroupCount;
+import org.briarproject.briar.api.introduction.IntroductionRequest;
+import org.briarproject.briar.api.introduction.IntroductionResponse;
+import org.briarproject.briar.api.introduction.event.IntroductionRequestReceivedEvent;
+import org.briarproject.briar.api.introduction.event.IntroductionResponseReceivedEvent;
+import org.briarproject.briar.api.messaging.ConversationManager;
+import org.briarproject.briar.api.messaging.PrivateMessageHeader;
+import org.briarproject.briar.api.messaging.event.PrivateMessageReceivedEvent;
+import org.briarproject.briar.api.sharing.InvitationRequest;
+import org.briarproject.briar.api.sharing.InvitationResponse;
+import org.briarproject.briar.api.sharing.event.InvitationRequestReceivedEvent;
+import org.briarproject.briar.api.sharing.event.InvitationResponseReceivedEvent;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.logging.Logger;
+
+import javax.annotation.Nullable;
+import javax.inject.Inject;
+
+import static android.support.v4.app.ActivityOptionsCompat.makeSceneTransitionAnimation;
+import static android.support.v4.view.ViewCompat.getTransitionName;
+import static java.util.logging.Level.INFO;
+import static java.util.logging.Level.WARNING;
+import static org.briarproject.briar.android.contact.ConversationActivity.CONTACT_ID;
+
+@MethodsNotNullByDefault
+@ParametersNotNullByDefault
+public class ContactListFragment extends BaseFragment implements EventListener {
+
+	public static final String TAG = ContactListFragment.class.getName();
+	private static final Logger LOG = Logger.getLogger(TAG);
+
+	@Inject
+	ConnectionRegistry connectionRegistry;
+	@Inject
+	EventBus eventBus;
+	@Inject
+	AndroidNotificationManager notificationManager;
+
+	private ContactListAdapter adapter;
+	private BriarRecyclerView list;
+
+	// Fields that are accessed from background threads must be volatile
+	@Inject
+	volatile ContactManager contactManager;
+	@Inject
+	volatile ConversationManager conversationManager;
+
+	public static ContactListFragment newInstance() {
+		Bundle args = new Bundle();
+		ContactListFragment fragment = new ContactListFragment();
+		fragment.setArguments(args);
+		return fragment;
+	}
+
+	@Override
+	public String getUniqueTag() {
+		return TAG;
+	}
+
+	@Override
+	public void injectFragment(ActivityComponent component) {
+		component.inject(this);
+	}
+
+	@Nullable
+	@Override
+	public View onCreateView(LayoutInflater inflater,
+			@Nullable ViewGroup container,
+			@Nullable Bundle savedInstanceState) {
+
+		View contentView = inflater.inflate(R.layout.list, container, false);
+
+		OnContactClickListener<ContactListItem> onContactClickListener =
+				new OnContactClickListener<ContactListItem>() {
+					@Override
+					public void onItemClick(View view, ContactListItem item) {
+						Intent i = new Intent(getActivity(),
+								ConversationActivity.class);
+						ContactId contactId = item.getContact().getId();
+						i.putExtra(CONTACT_ID, contactId.getInt());
+
+						// work-around for android bug #224270
+						if (Build.VERSION.SDK_INT >= 23) {
+							ContactListItemViewHolder holder =
+									(ContactListItemViewHolder) list
+											.getRecyclerView()
+											.findViewHolderForAdapterPosition(
+													adapter.findItemPosition(
+															item));
+							Pair<View, String> avatar =
+									Pair.create((View) holder.avatar,
+											getTransitionName(holder.avatar));
+							Pair<View, String> bulb =
+									Pair.create((View) holder.bulb,
+											getTransitionName(holder.bulb));
+							ActivityOptionsCompat options =
+									makeSceneTransitionAnimation(getActivity(),
+											avatar, bulb);
+							ActivityCompat.startActivity(getActivity(), i,
+									options.toBundle());
+						} else {
+							getActivity().startActivity(i);
+						}
+					}
+				};
+		adapter = new ContactListAdapter(getContext(), onContactClickListener);
+		list = (BriarRecyclerView) contentView.findViewById(R.id.list);
+		list.setLayoutManager(new LinearLayoutManager(getContext()));
+		list.setAdapter(adapter);
+		list.setEmptyText(getString(R.string.no_contacts));
+
+		return contentView;
+	}
+
+	@Override
+	public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
+		inflater.inflate(R.menu.contact_list_actions, menu);
+		super.onCreateOptionsMenu(menu, inflater);
+	}
+
+	@Override
+	public boolean onOptionsItemSelected(final MenuItem item) {
+		// Handle presses on the action bar items
+		switch (item.getItemId()) {
+			case R.id.action_add_contact:
+				Intent intent =
+						new Intent(getContext(), KeyAgreementActivity.class);
+				startActivity(intent);
+				return true;
+			default:
+				return super.onOptionsItemSelected(item);
+		}
+	}
+
+	@Override
+	public void onStart() {
+		super.onStart();
+		notificationManager.blockAllContactNotifications();
+		notificationManager.clearAllContactNotifications();
+		eventBus.addListener(this);
+		loadContacts();
+		list.startPeriodicUpdate();
+	}
+
+	@Override
+	public void onStop() {
+		super.onStop();
+		eventBus.removeListener(this);
+		notificationManager.unblockAllContactNotifications();
+		adapter.clear();
+		list.showProgressBar();
+		list.stopPeriodicUpdate();
+	}
+
+	private void loadContacts() {
+		final int revision = adapter.getRevision();
+		listener.runOnDbThread(new Runnable() {
+			@Override
+			public void run() {
+				try {
+					long now = System.currentTimeMillis();
+					List<ContactListItem> contacts = new ArrayList<>();
+					for (Contact c : contactManager.getActiveContacts()) {
+						try {
+							ContactId id = c.getId();
+							GroupCount count =
+									conversationManager.getGroupCount(id);
+							boolean connected =
+									connectionRegistry.isConnected(c.getId());
+							contacts.add(new ContactListItem(c, connected,
+									count));
+						} catch (NoSuchContactException e) {
+							// Continue
+						}
+					}
+					long duration = System.currentTimeMillis() - now;
+					if (LOG.isLoggable(INFO))
+						LOG.info("Full load took " + duration + " ms");
+					displayContacts(revision, contacts);
+				} catch (DbException e) {
+					if (LOG.isLoggable(WARNING))
+						LOG.log(WARNING, e.toString(), e);
+				}
+			}
+		});
+	}
+
+	private void displayContacts(final int revision,
+			final List<ContactListItem> contacts) {
+		runOnUiThreadUnlessDestroyed(new Runnable() {
+			@Override
+			public void run() {
+				if (revision == adapter.getRevision()) {
+					adapter.incrementRevision();
+					if (contacts.isEmpty()) list.showData();
+					else adapter.addAll(contacts);
+				} else {
+					LOG.info("Concurrent update, reloading");
+					loadContacts();
+				}
+			}
+		});
+	}
+
+	@Override
+	public void eventOccurred(Event e) {
+		if (e instanceof ContactStatusChangedEvent) {
+			ContactStatusChangedEvent c = (ContactStatusChangedEvent) e;
+			if (c.isActive()) {
+				LOG.info("Contact activated, reloading");
+				loadContacts();
+			} else {
+				LOG.info("Contact deactivated, removing item");
+				removeItem(c.getContactId());
+			}
+		} else if (e instanceof ContactConnectedEvent) {
+			setConnected(((ContactConnectedEvent) e).getContactId(), true);
+		} else if (e instanceof ContactDisconnectedEvent) {
+			setConnected(((ContactDisconnectedEvent) e).getContactId(), false);
+		} else if (e instanceof ContactRemovedEvent) {
+			LOG.info("Contact removed, removing item");
+			removeItem(((ContactRemovedEvent) e).getContactId());
+		} else if (e instanceof PrivateMessageReceivedEvent) {
+			LOG.info("Private message received, updating item");
+			PrivateMessageReceivedEvent p = (PrivateMessageReceivedEvent) e;
+			PrivateMessageHeader h = p.getMessageHeader();
+			updateItem(p.getContactId(), h);
+		} else if (e instanceof IntroductionRequestReceivedEvent) {
+			LOG.info("Introduction request received, updating item");
+			IntroductionRequestReceivedEvent m =
+					(IntroductionRequestReceivedEvent) e;
+			IntroductionRequest ir = m.getIntroductionRequest();
+			updateItem(m.getContactId(), ir);
+		} else if (e instanceof IntroductionResponseReceivedEvent) {
+			LOG.info("Introduction response received, updating item");
+			IntroductionResponseReceivedEvent m =
+					(IntroductionResponseReceivedEvent) e;
+			IntroductionResponse ir = m.getIntroductionResponse();
+			updateItem(m.getContactId(), ir);
+		} else if (e instanceof InvitationRequestReceivedEvent) {
+			LOG.info("Invitation Request received, update item");
+			InvitationRequestReceivedEvent m =
+					(InvitationRequestReceivedEvent) e;
+			InvitationRequest ir = m.getRequest();
+			updateItem(m.getContactId(), ir);
+		} else if (e instanceof InvitationResponseReceivedEvent) {
+			LOG.info("Invitation response received, updating item");
+			InvitationResponseReceivedEvent m =
+					(InvitationResponseReceivedEvent) e;
+			InvitationResponse ir = m.getResponse();
+			updateItem(m.getContactId(), ir);
+		}
+	}
+
+	private void updateItem(final ContactId c, final BaseMessageHeader h) {
+		runOnUiThreadUnlessDestroyed(new Runnable() {
+			@Override
+			public void run() {
+				adapter.incrementRevision();
+				int position = adapter.findItemPosition(c);
+				ContactListItem item = adapter.getItemAt(position);
+				if (item != null) {
+					ConversationItem i = ConversationItem.from(getContext(), h);
+					item.addMessage(i);
+					adapter.updateItemAt(position, item);
+				}
+			}
+		});
+	}
+
+	private void removeItem(final ContactId c) {
+		runOnUiThreadUnlessDestroyed(new Runnable() {
+			@Override
+			public void run() {
+				adapter.incrementRevision();
+				int position = adapter.findItemPosition(c);
+				ContactListItem item = adapter.getItemAt(position);
+				if (item != null) adapter.remove(item);
+			}
+		});
+	}
+
+	private void setConnected(final ContactId c, final boolean connected) {
+		runOnUiThreadUnlessDestroyed(new Runnable() {
+			@Override
+			public void run() {
+				adapter.incrementRevision();
+				int position = adapter.findItemPosition(c);
+				ContactListItem item = adapter.getItemAt(position);
+				if (item != null) {
+					item.setConnected(connected);
+					adapter.notifyItemChanged(position);
+				}
+			}
+		});
+	}
+
+}

briar-android/src/main/java/org/briarproject/briar/android/contact/ContactListItem.java

@@ -0,0 +1,53 @@
+package org.briarproject.briar.android.contact;
+
+import org.briarproject.bramble.api.contact.Contact;
+import org.briarproject.bramble.api.nullsafety.NotNullByDefault;
+import org.briarproject.briar.api.client.MessageTracker.GroupCount;
+
+import javax.annotation.concurrent.NotThreadSafe;
+
+@NotThreadSafe
+@NotNullByDefault
+public class ContactListItem extends ContactItem {
+
+	private boolean connected, empty;
+	private long timestamp;
+	private int unread;
+
+	public ContactListItem(Contact contact, boolean connected,
+			GroupCount count) {
+		super(contact);
+		this.connected = connected;
+		this.empty = count.getMsgCount() == 0;
+		this.unread = count.getUnreadCount();
+		this.timestamp = count.getLatestMsgTime();
+	}
+
+	void addMessage(ConversationItem message) {
+		empty = false;
+		if (message.getTime() > timestamp) timestamp = message.getTime();
+		if (!message.isRead())
+			unread++;
+	}
+
+	boolean isConnected() {
+		return connected;
+	}
+
+	void setConnected(boolean connected) {
+		this.connected = connected;
+	}
+
+	boolean isEmpty() {
+		return empty;
+	}
+
+	long getTimestamp() {
+		return timestamp;
+	}
+
+	int getUnreadCount() {
+		return unread;
+	}
+
+}

briar-android/src/main/java/org/briarproject/briar/android/contact/ContactListItemViewHolder.java

@@ -0,0 +1,68 @@
+package org.briarproject.briar.android.contact;
+
+import android.support.annotation.UiThread;
+import android.view.View;
+import android.widget.ImageView;
+import android.widget.TextView;
+
+import org.briarproject.bramble.api.contact.ContactId;
+import org.briarproject.bramble.api.nullsafety.NotNullByDefault;
+import org.briarproject.briar.R;
+import org.briarproject.briar.android.contact.BaseContactListAdapter.OnContactClickListener;
+import org.briarproject.briar.android.util.UiUtils;
+
+import javax.annotation.Nullable;
+
+import static android.support.v4.view.ViewCompat.setTransitionName;
+import static org.briarproject.briar.android.util.UiUtils.formatDate;
+
+@UiThread
+@NotNullByDefault
+class ContactListItemViewHolder extends ContactItemViewHolder<ContactListItem> {
+
+	protected final ImageView bulb;
+	private final TextView unread;
+	private final TextView date;
+
+	ContactListItemViewHolder(View v) {
+		super(v);
+		bulb = (ImageView) v.findViewById(R.id.bulbView);
+		unread = (TextView) v.findViewById(R.id.unreadCountView);
+		date = (TextView) v.findViewById(R.id.dateView);
+	}
+
+	@Override
+	protected void bind(ContactListItem item, @Nullable
+			OnContactClickListener<ContactListItem> listener) {
+		super.bind(item, listener);
+
+		// unread count
+		int unreadCount = item.getUnreadCount();
+		if (unreadCount > 0) {
+			unread.setText(String.valueOf(unreadCount));
+			unread.setVisibility(View.VISIBLE);
+		} else {
+			unread.setVisibility(View.INVISIBLE);
+		}
+
+		// date of last message
+		if (item.isEmpty()) {
+			date.setText(R.string.date_no_private_messages);
+		} else {
+			long timestamp = item.getTimestamp();
+			date.setText(formatDate(date.getContext(), timestamp));
+		}
+
+		// online/offline
+		if (item.isConnected()) {
+			bulb.setImageResource(R.drawable.contact_connected);
+		} else {
+			bulb.setImageResource(R.drawable.contact_disconnected);
+		}
+
+		ContactId c = item.getContact().getId();
+		setTransitionName(avatar, UiUtils.getAvatarTransitionName(c));
+		setTransitionName(bulb, UiUtils.getBulbTransitionName(c));
+	}
+
+}

briar-android/src/main/java/org/briarproject/briar/android/contact/ContactModule.java

@@ -0,0 +1,7 @@
+package org.briarproject.briar.android.contact;
+
+import dagger.Module;
+
+@Module
+public class ContactModule {
+}

briar-android/src/main/java/org/briarproject/briar/android/contact/ConversationActivity.java

@@ -0,0 +1,920 @@
+package org.briarproject.briar.android.contact;
+
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.os.Bundle;
+import android.support.annotation.UiThread;
+import android.support.design.widget.Snackbar;
+import android.support.v4.app.ActivityCompat;
+import android.support.v4.app.ActivityOptionsCompat;
+import android.support.v4.content.ContextCompat;
+import android.support.v4.view.ViewCompat;
+import android.support.v7.app.ActionBar;
+import android.support.v7.app.AlertDialog;
+import android.support.v7.widget.ActionMenuView;
+import android.support.v7.widget.LinearLayoutManager;
+import android.support.v7.widget.Toolbar;
+import android.util.SparseArray;
+import android.view.Menu;
+import android.view.MenuInflater;
+import android.view.MenuItem;
+import android.view.MotionEvent;
+import android.view.View;
+import android.widget.ImageView;
+import android.widget.TextView;
+import android.widget.Toast;
+
+import org.briarproject.bramble.api.FormatException;
+import org.briarproject.bramble.api.contact.Contact;
+import org.briarproject.bramble.api.contact.ContactId;
+import org.briarproject.bramble.api.contact.ContactManager;
+import org.briarproject.bramble.api.contact.event.ContactRemovedEvent;
+import org.briarproject.bramble.api.crypto.CryptoExecutor;
+import org.briarproject.bramble.api.db.DatabaseExecutor;
+import org.briarproject.bramble.api.db.DbException;
+import org.briarproject.bramble.api.db.NoSuchContactException;
+import org.briarproject.bramble.api.event.Event;
+import org.briarproject.bramble.api.event.EventBus;
+import org.briarproject.bramble.api.event.EventListener;
+import org.briarproject.bramble.api.identity.AuthorId;
+import org.briarproject.bramble.api.nullsafety.MethodsNotNullByDefault;
+import org.briarproject.bramble.api.nullsafety.ParametersNotNullByDefault;
+import org.briarproject.bramble.api.plugin.ConnectionRegistry;
+import org.briarproject.bramble.api.plugin.event.ContactConnectedEvent;
+import org.briarproject.bramble.api.plugin.event.ContactDisconnectedEvent;
+import org.briarproject.bramble.api.settings.Settings;
+import org.briarproject.bramble.api.settings.SettingsManager;
+import org.briarproject.bramble.api.sync.GroupId;
+import org.briarproject.bramble.api.sync.Message;
+import org.briarproject.bramble.api.sync.MessageId;
+import org.briarproject.bramble.api.sync.event.MessagesAckedEvent;
+import org.briarproject.bramble.api.sync.event.MessagesSentEvent;
+import org.briarproject.bramble.util.StringUtils;
+import org.briarproject.briar.R;
+import org.briarproject.briar.android.activity.ActivityComponent;
+import org.briarproject.briar.android.activity.BriarActivity;
+import org.briarproject.briar.android.contact.ConversationAdapter.ConversationListener;
+import org.briarproject.briar.android.introduction.IntroductionActivity;
+import org.briarproject.briar.android.util.UiUtils;
+import org.briarproject.briar.android.view.BriarRecyclerView;
+import org.briarproject.briar.android.view.TextInputView;
+import org.briarproject.briar.android.view.TextInputView.TextInputListener;
+import org.briarproject.briar.api.android.AndroidNotificationManager;
+import org.briarproject.briar.api.blog.BlogSharingManager;
+import org.briarproject.briar.api.client.ProtocolStateException;
+import org.briarproject.briar.api.client.SessionId;
+import org.briarproject.briar.api.forum.ForumSharingManager;
+import org.briarproject.briar.api.introduction.IntroductionManager;
+import org.briarproject.briar.api.introduction.IntroductionMessage;
+import org.briarproject.briar.api.introduction.IntroductionRequest;
+import org.briarproject.briar.api.introduction.IntroductionResponse;
+import org.briarproject.briar.api.introduction.event.IntroductionRequestReceivedEvent;
+import org.briarproject.briar.api.introduction.event.IntroductionResponseReceivedEvent;
+import org.briarproject.briar.api.messaging.MessagingManager;
+import org.briarproject.briar.api.messaging.PrivateMessage;
+import org.briarproject.briar.api.messaging.PrivateMessageFactory;
+import org.briarproject.briar.api.messaging.PrivateMessageHeader;
+import org.briarproject.briar.api.messaging.event.PrivateMessageReceivedEvent;
+import org.briarproject.briar.api.privategroup.invitation.GroupInvitationManager;
+import org.briarproject.briar.api.sharing.InvitationMessage;
+import org.briarproject.briar.api.sharing.InvitationRequest;
+import org.briarproject.briar.api.sharing.InvitationResponse;
+import org.briarproject.briar.api.sharing.event.InvitationRequestReceivedEvent;
+import org.briarproject.briar.api.sharing.event.InvitationResponseReceivedEvent;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.Executor;
+import java.util.logging.Logger;
+
+import javax.annotation.Nullable;
+import javax.inject.Inject;
+
+import de.hdodenhof.circleimageview.CircleImageView;
+import im.delight.android.identicons.IdenticonDrawable;
+import uk.co.samuelwall.materialtaptargetprompt.MaterialTapTargetPrompt;
+import uk.co.samuelwall.materialtaptargetprompt.MaterialTapTargetPrompt.OnHidePromptListener;
+
+import static android.support.v4.app.ActivityOptionsCompat.makeCustomAnimation;
+import static android.support.v7.util.SortedList.INVALID_POSITION;
+import static android.widget.Toast.LENGTH_SHORT;
+import static java.util.logging.Level.INFO;
+import static java.util.logging.Level.WARNING;
+import static org.briarproject.briar.android.settings.SettingsFragment.SETTINGS_NAMESPACE;
+import static org.briarproject.briar.api.messaging.MessagingConstants.MAX_PRIVATE_MESSAGE_BODY_LENGTH;
+
+@MethodsNotNullByDefault
+@ParametersNotNullByDefault
+public class ConversationActivity extends BriarActivity
+		implements EventListener, ConversationListener, TextInputListener {
+
+	public static final String CONTACT_ID = "briar.CONTACT_ID";
+
+	private static final Logger LOG =
+			Logger.getLogger(ConversationActivity.class.getName());
+	private static final int REQUEST_CODE_INTRODUCTION = 1;
+	private static final String SHOW_ONBOARDING_INTRODUCTION =
+			"showOnboardingIntroduction";
+
+	@Inject
+	AndroidNotificationManager notificationManager;
+	@Inject
+	ConnectionRegistry connectionRegistry;
+	@Inject
+	@CryptoExecutor
+	Executor cryptoExecutor;
+
+	private final Map<MessageId, String> bodyCache = new ConcurrentHashMap<>();
+
+	private ConversationAdapter adapter;
+	private Toolbar toolbar;
+	private CircleImageView toolbarAvatar;
+	private ImageView toolbarStatus;
+	private TextView toolbarTitle;
+	private BriarRecyclerView list;
+	private TextInputView textInputView;
+
+	// Fields that are accessed from background threads must be volatile
+	@Inject
+	volatile ContactManager contactManager;
+	@Inject
+	volatile MessagingManager messagingManager;
+	@Inject
+	volatile EventBus eventBus;
+	@Inject
+	volatile SettingsManager settingsManager;
+	@Inject
+	volatile PrivateMessageFactory privateMessageFactory;
+	@Inject
+	volatile IntroductionManager introductionManager;
+	@Inject
+	volatile ForumSharingManager forumSharingManager;
+	@Inject
+	volatile BlogSharingManager blogSharingManager;
+	@Inject
+	volatile GroupInvitationManager groupInvitationManager;
+
+	private volatile ContactId contactId;
+	private volatile String contactName;
+	private volatile AuthorId contactAuthorId;
+	private volatile GroupId messagingGroupId;
+
+	@SuppressWarnings("ConstantConditions")
+	@Override
+	public void onCreate(@Nullable Bundle state) {
+		super.onCreate(state);
+
+		Intent i = getIntent();
+		int id = i.getIntExtra(CONTACT_ID, -1);
+		if (id == -1) throw new IllegalStateException();
+		contactId = new ContactId(id);
+
+		setContentView(R.layout.activity_conversation);
+
+		// Custom Toolbar
+		toolbar = (Toolbar) findViewById(R.id.toolbar);
+		if (toolbar != null) {
+			toolbarAvatar =
+					(CircleImageView) toolbar.findViewById(R.id.contactAvatar);
+			toolbarStatus =
+					(ImageView) toolbar.findViewById(R.id.contactStatus);
+			toolbarTitle = (TextView) toolbar.findViewById(R.id.contactName);
+			setSupportActionBar(toolbar);
+		}
+		ActionBar ab = getSupportActionBar();
+		if (ab != null) {
+			ab.setDisplayShowHomeEnabled(true);
+			ab.setDisplayHomeAsUpEnabled(true);
+			ab.setDisplayShowCustomEnabled(true);
+			ab.setDisplayShowTitleEnabled(false);
+		}
+
+		ViewCompat.setTransitionName(toolbarAvatar,
+				UiUtils.getAvatarTransitionName(contactId));
+		ViewCompat.setTransitionName(toolbarStatus,
+				UiUtils.getBulbTransitionName(contactId));
+
+		adapter = new ConversationAdapter(this, this);
+		list = (BriarRecyclerView) findViewById(R.id.conversationView);
+		list.setLayoutManager(new LinearLayoutManager(this));
+		list.setAdapter(adapter);
+		list.setEmptyText(getString(R.string.no_private_messages));
+
+		textInputView = (TextInputView) findViewById(R.id.text_input_container);
+		textInputView.setListener(this);
+	}
+
+	@Override
+	public void injectActivity(ActivityComponent component) {
+		component.inject(this);
+	}
+
+	@Override
+	protected void onActivityResult(int request, int result, Intent data) {
+		super.onActivityResult(request, result, data);
+
+		if (request == REQUEST_CODE_INTRODUCTION && result == RESULT_OK) {
+			Snackbar snackbar = Snackbar.make(list, R.string.introduction_sent,
+					Snackbar.LENGTH_SHORT);
+			snackbar.getView().setBackgroundResource(R.color.briar_primary);
+			snackbar.show();
+		}
+	}
+
+	@Override
+	public void onStart() {
+		super.onStart();
+		eventBus.addListener(this);
+		notificationManager.blockContactNotification(contactId);
+		notificationManager.clearContactNotification(contactId);
+		loadContactDetails();
+		loadMessages();
+		list.startPeriodicUpdate();
+	}
+
+	@Override
+	public void onStop() {
+		super.onStop();
+		eventBus.removeListener(this);
+		notificationManager.unblockContactNotification(contactId);
+		list.stopPeriodicUpdate();
+	}
+
+	@Override
+	public boolean onCreateOptionsMenu(Menu menu) {
+		// Inflate the menu items for use in the action bar
+		MenuInflater inflater = getMenuInflater();
+		inflater.inflate(R.menu.conversation_actions, menu);
+
+		enableIntroductionActionIfAvailable(
+				menu.findItem(R.id.action_introduction));
+
+		return super.onCreateOptionsMenu(menu);
+	}
+
+	@Override
+	public boolean onOptionsItemSelected(final MenuItem item) {
+		// Handle presses on the action bar items
+		switch (item.getItemId()) {
+			case android.R.id.home:
+				onBackPressed();
+				return true;
+			case R.id.action_introduction:
+				if (contactId == null) return false;
+				Intent intent = new Intent(this, IntroductionActivity.class);
+				intent.putExtra(IntroductionActivity.CONTACT_ID,
+						contactId.getInt());
+				ActivityOptionsCompat options =
+						makeCustomAnimation(this, android.R.anim.slide_in_left,
+								android.R.anim.slide_out_right);
+				ActivityCompat.startActivityForResult(this, intent,
+						REQUEST_CODE_INTRODUCTION, options.toBundle());
+				return true;
+			case R.id.action_social_remove_person:
+				askToRemoveContact();
+				return true;
+			default:
+				return super.onOptionsItemSelected(item);
+		}
+	}
+
+	@Override
+	public void onBackPressed() {
+		// FIXME disabled exit transition, because it doesn't work for some reason #318
+		//supportFinishAfterTransition();
+		finish();
+	}
+
+	private void loadContactDetails() {
+		runOnDbThread(new Runnable() {
+			@Override
+			public void run() {
+				try {
+					long now = System.currentTimeMillis();
+					if (contactName == null || contactAuthorId == null) {
+						Contact contact = contactManager.getContact(contactId);
+						contactName = contact.getAuthor().getName();
+						contactAuthorId = contact.getAuthor().getId();
+					}
+					long duration = System.currentTimeMillis() - now;
+					if (LOG.isLoggable(INFO))
+						LOG.info("Loading contact took " + duration + " ms");
+					displayContactDetails();
+				} catch (NoSuchContactException e) {
+					finishOnUiThread();
+				} catch (DbException e) {
+					if (LOG.isLoggable(WARNING))
+						LOG.log(WARNING, e.toString(), e);
+				}
+			}
+		});
+	}
+
+	private void displayContactDetails() {
+		runOnUiThreadUnlessDestroyed(new Runnable() {
+			@Override
+			public void run() {
+				toolbarAvatar.setImageDrawable(
+						new IdenticonDrawable(contactAuthorId.getBytes()));
+				toolbarTitle.setText(contactName);
+
+				if (connectionRegistry.isConnected(contactId)) {
+					toolbarStatus.setImageDrawable(ContextCompat
+							.getDrawable(ConversationActivity.this,
+									R.drawable.contact_online));
+					toolbarStatus
+							.setContentDescription(getString(R.string.online));
+				} else {
+					toolbarStatus.setImageDrawable(ContextCompat
+							.getDrawable(ConversationActivity.this,
+									R.drawable.contact_offline));
+					toolbarStatus
+							.setContentDescription(getString(R.string.offline));
+				}
+			}
+		});
+	}
+
+	private void loadMessages() {
+		final int revision = adapter.getRevision();
+		runOnDbThread(new Runnable() {
+			@Override
+			public void run() {
+				try {
+					long now = System.currentTimeMillis();
+					Collection<PrivateMessageHeader> headers =
+							messagingManager.getMessageHeaders(contactId);
+					Collection<IntroductionMessage> introductions =
+							introductionManager
+									.getIntroductionMessages(contactId);
+					Collection<InvitationMessage> forumInvitations =
+							forumSharingManager
+									.getInvitationMessages(contactId);
+					Collection<InvitationMessage> blogInvitations =
+							blogSharingManager
+									.getInvitationMessages(contactId);
+					Collection<InvitationMessage> groupInvitations =
+							groupInvitationManager
+									.getInvitationMessages(contactId);
+					List<InvitationMessage> invitations = new ArrayList<>(
+							forumInvitations.size() + blogInvitations.size());
+					invitations.addAll(forumInvitations);
+					invitations.addAll(blogInvitations);
+					invitations.addAll(groupInvitations);
+					long duration = System.currentTimeMillis() - now;
+					if (LOG.isLoggable(INFO))
+						LOG.info("Loading messages took " + duration + " ms");
+					displayMessages(revision, headers, introductions,
+							invitations);
+				} catch (NoSuchContactException e) {
+					finishOnUiThread();
+				} catch (DbException e) {
+					if (LOG.isLoggable(WARNING))
+						LOG.log(WARNING, e.toString(), e);
+				}
+			}
+		});
+	}
+
+	private void displayMessages(final int revision,
+			final Collection<PrivateMessageHeader> headers,
+			final Collection<IntroductionMessage> introductions,
+			final Collection<InvitationMessage> invitations) {
+		runOnUiThreadUnlessDestroyed(new Runnable() {
+			@Override
+			public void run() {
+				if (revision == adapter.getRevision()) {
+					adapter.incrementRevision();
+					textInputView.setSendButtonEnabled(true);
+					List<ConversationItem> items = createItems(headers,
+							introductions, invitations);
+					if (items.isEmpty()) list.showData();
+					else adapter.addAll(items);
+					// Scroll to the bottom
+					list.scrollToPosition(adapter.getItemCount() - 1);
+				} else {
+					LOG.info("Concurrent update, reloading");
+					loadMessages();
+				}
+			}
+		});
+	}
+
+	private List<ConversationItem> createItems(
+			Collection<PrivateMessageHeader> headers,
+			Collection<IntroductionMessage> introductions,
+			Collection<InvitationMessage> invitations) {
+		int size =
+				headers.size() + introductions.size() + invitations.size();
+		List<ConversationItem> items = new ArrayList<>(size);
+		for (PrivateMessageHeader h : headers) {
+			ConversationItem item = ConversationItem.from(h);
+			String body = bodyCache.get(h.getId());
+			if (body == null) loadMessageBody(h.getId());
+			else item.setBody(body);
+			items.add(item);
+		}
+		for (IntroductionMessage m : introductions) {
+			ConversationItem item;
+			if (m instanceof IntroductionRequest) {
+				IntroductionRequest i = (IntroductionRequest) m;
+				item = ConversationItem.from(this, contactName, i);
+			} else {
+				IntroductionResponse i = (IntroductionResponse) m;
+				item = ConversationItem.from(this, contactName, i);
+			}
+			items.add(item);
+		}
+		for (InvitationMessage i : invitations) {
+			ConversationItem item;
+			if (i instanceof InvitationRequest) {
+				InvitationRequest r = (InvitationRequest) i;
+				item = ConversationItem.from(this, contactName, r);
+			} else {
+				InvitationResponse r = (InvitationResponse) i;
+				item = ConversationItem.from(this, contactName, r);
+			}
+			items.add(item);
+		}
+		return items;
+	}
+
+	private void loadMessageBody(final MessageId m) {
+		runOnDbThread(new Runnable() {
+			@Override
+			public void run() {
+				try {
+					long now = System.currentTimeMillis();
+					String body = messagingManager.getMessageBody(m);
+					long duration = System.currentTimeMillis() - now;
+					if (LOG.isLoggable(INFO))
+						LOG.info("Loading body took " + duration + " ms");
+					displayMessageBody(m, body);
+				} catch (DbException e) {
+					if (LOG.isLoggable(WARNING))
+						LOG.log(WARNING, e.toString(), e);
+				}
+			}
+		});
+	}
+
+	private void displayMessageBody(final MessageId m, final String body) {
+		runOnUiThreadUnlessDestroyed(new Runnable() {
+			@Override
+			public void run() {
+				bodyCache.put(m, body);
+				SparseArray<ConversationItem> messages =
+						adapter.getPrivateMessages();
+				for (int i = 0; i < messages.size(); i++) {
+					ConversationItem item = messages.valueAt(i);
+					if (item.getId().equals(m)) {
+						item.setBody(body);
+						adapter.notifyItemChanged(messages.keyAt(i));
+						list.scrollToPosition(adapter.getItemCount() - 1);
+						return;
+					}
+				}
+			}
+		});
+	}
+
+	private void addConversationItem(final ConversationItem item) {
+		runOnUiThreadUnlessDestroyed(new Runnable() {
+			@Override
+			public void run() {
+				adapter.incrementRevision();
+				adapter.add(item);
+				// Scroll to the bottom
+				list.scrollToPosition(adapter.getItemCount() - 1);
+			}
+		});
+	}
+
+	@Override
+	public void eventOccurred(Event e) {
+		if (e instanceof ContactRemovedEvent) {
+			ContactRemovedEvent c = (ContactRemovedEvent) e;
+			if (c.getContactId().equals(contactId)) {
+				LOG.info("Contact removed");
+				finishOnUiThread();
+			}
+		} else if (e instanceof PrivateMessageReceivedEvent) {
+			PrivateMessageReceivedEvent p = (PrivateMessageReceivedEvent) e;
+			if (p.getContactId().equals(contactId)) {
+				LOG.info("Message received, adding");
+				PrivateMessageHeader h = p.getMessageHeader();
+				addConversationItem(ConversationItem.from(h));
+				loadMessageBody(h.getId());
+			}
+		} else if (e instanceof MessagesSentEvent) {
+			MessagesSentEvent m = (MessagesSentEvent) e;
+			if (m.getContactId().equals(contactId)) {
+				LOG.info("Messages sent");
+				markMessages(m.getMessageIds(), true, false);
+			}
+		} else if (e instanceof MessagesAckedEvent) {
+			MessagesAckedEvent m = (MessagesAckedEvent) e;
+			if (m.getContactId().equals(contactId)) {
+				LOG.info("Messages acked");
+				markMessages(m.getMessageIds(), true, true);
+			}
+		} else if (e instanceof ContactConnectedEvent) {
+			ContactConnectedEvent c = (ContactConnectedEvent) e;
+			if (c.getContactId().equals(contactId)) {
+				LOG.info("Contact connected");
+				displayContactDetails();
+			}
+		} else if (e instanceof ContactDisconnectedEvent) {
+			ContactDisconnectedEvent c = (ContactDisconnectedEvent) e;
+			if (c.getContactId().equals(contactId)) {
+				LOG.info("Contact disconnected");
+				displayContactDetails();
+			}
+		} else if (e instanceof IntroductionRequestReceivedEvent) {
+			IntroductionRequestReceivedEvent event =
+					(IntroductionRequestReceivedEvent) e;
+			if (event.getContactId().equals(contactId)) {
+				LOG.info("Introduction request received, adding...");
+				IntroductionRequest ir = event.getIntroductionRequest();
+				ConversationItem item =
+						ConversationItem.from(this, contactName, ir);
+				addConversationItem(item);
+			}
+		} else if (e instanceof IntroductionResponseReceivedEvent) {
+			IntroductionResponseReceivedEvent event =
+					(IntroductionResponseReceivedEvent) e;
+			if (event.getContactId().equals(contactId)) {
+				LOG.info("Introduction response received, adding...");
+				IntroductionResponse ir = event.getIntroductionResponse();
+				ConversationItem item =
+						ConversationItem.from(this, contactName, ir);
+				addConversationItem(item);
+			}
+		} else if (e instanceof InvitationRequestReceivedEvent) {
+			InvitationRequestReceivedEvent event =
+					(InvitationRequestReceivedEvent) e;
+			if (event.getContactId().equals(contactId)) {
+				LOG.info("Invitation received, adding...");
+				InvitationRequest ir = event.getRequest();
+				ConversationItem item =
+						ConversationItem.from(this, contactName, ir);
+				addConversationItem(item);
+			}
+		} else if (e instanceof InvitationResponseReceivedEvent) {
+			InvitationResponseReceivedEvent event =
+					(InvitationResponseReceivedEvent) e;
+			if (event.getContactId().equals(contactId)) {
+				LOG.info("Invitation response received, adding...");
+				InvitationResponse ir = event.getResponse();
+				ConversationItem item =
+						ConversationItem.from(this, contactName, ir);
+				addConversationItem(item);
+			}
+		}
+	}
+
+	private void markMessages(final Collection<MessageId> messageIds,
+			final boolean sent, final boolean seen) {
+		runOnUiThreadUnlessDestroyed(new Runnable() {
+			@Override
+			public void run() {
+				adapter.incrementRevision();
+				Set<MessageId> messages = new HashSet<>(messageIds);
+				SparseArray<ConversationOutItem> list =
+						adapter.getOutgoingMessages();
+				for (int i = 0; i < list.size(); i++) {
+					ConversationOutItem item = list.valueAt(i);
+					if (messages.contains(item.getId())) {
+						item.setSent(sent);
+						item.setSeen(seen);
+						adapter.notifyItemChanged(list.keyAt(i));
+					}
+				}
+			}
+		});
+	}
+
+	@Override
+	public void onSendClick(String text) {
+		if (text.equals("")) return;
+		text = StringUtils.truncateUtf8(text, MAX_PRIVATE_MESSAGE_BODY_LENGTH);
+		long timestamp = System.currentTimeMillis();
+		timestamp = Math.max(timestamp, getMinTimestampForNewMessage());
+		if (messagingGroupId == null) loadGroupId(text, timestamp);
+		else createMessage(text, timestamp);
+		textInputView.setText("");
+	}
+
+	private long getMinTimestampForNewMessage() {
+		// Don't use an earlier timestamp than the newest message
+		ConversationItem item = adapter.getLastItem();
+		return item == null ? 0 : item.getTime() + 1;
+	}
+
+	private void loadGroupId(final String body, final long timestamp) {
+		runOnDbThread(new Runnable() {
+			@Override
+			public void run() {
+				try {
+					messagingGroupId =
+							messagingManager.getConversationId(contactId);
+					createMessage(body, timestamp);
+				} catch (DbException e) {
+					if (LOG.isLoggable(WARNING))
+						LOG.log(WARNING, e.toString(), e);
+				}
+
+			}
+		});
+	}
+
+	private void createMessage(final String body, final long timestamp) {
+		cryptoExecutor.execute(new Runnable() {
+			@Override
+			public void run() {
+				try {
+					storeMessage(privateMessageFactory.createPrivateMessage(
+							messagingGroupId, timestamp, body), body);
+				} catch (FormatException e) {
+					throw new RuntimeException(e);
+				}
+			}
+		});
+	}
+
+	private void storeMessage(final PrivateMessage m, final String body) {
+		runOnDbThread(new Runnable() {
+			@Override
+			public void run() {
+				try {
+					long now = System.currentTimeMillis();
+					messagingManager.addLocalMessage(m);
+					long duration = System.currentTimeMillis() - now;
+					if (LOG.isLoggable(INFO))
+						LOG.info("Storing message took " + duration + " ms");
+					Message message = m.getMessage();
+					PrivateMessageHeader h = new PrivateMessageHeader(
+							message.getId(), message.getGroupId(),
+							message.getTimestamp(), true, false, false, false);
+					ConversationItem item = ConversationItem.from(h);
+					item.setBody(body);
+					bodyCache.put(message.getId(), body);
+					addConversationItem(item);
+				} catch (DbException e) {
+					if (LOG.isLoggable(WARNING))
+						LOG.log(WARNING, e.toString(), e);
+				}
+			}
+		});
+	}
+
+	private void askToRemoveContact() {
+		DialogInterface.OnClickListener okListener =
+				new DialogInterface.OnClickListener() {
+					@Override
+					public void onClick(DialogInterface dialog, int which) {
+						removeContact();
+					}
+				};
+		AlertDialog.Builder builder =
+				new AlertDialog.Builder(ConversationActivity.this,
+						R.style.BriarDialogTheme);
+		builder.setTitle(getString(R.string.dialog_title_delete_contact));
+		builder.setMessage(getString(R.string.dialog_message_delete_contact));
+		builder.setNegativeButton(R.string.delete, okListener);
+		builder.setPositiveButton(R.string.cancel, null);
+		builder.show();
+	}
+
+	private void removeContact() {
+		runOnDbThread(new Runnable() {
+			@Override
+			public void run() {
+				try {
+					contactManager.removeContact(contactId);
+				} catch (DbException e) {
+					if (LOG.isLoggable(WARNING))
+						LOG.log(WARNING, e.toString(), e);
+				} finally {
+					finishAfterContactRemoved();
+				}
+			}
+		});
+	}
+
+	private void finishAfterContactRemoved() {
+		runOnUiThreadUnlessDestroyed(new Runnable() {
+			@Override
+			public void run() {
+				String deleted = getString(R.string.contact_deleted_toast);
+				Toast.makeText(ConversationActivity.this, deleted, LENGTH_SHORT)
+						.show();
+				finish();
+			}
+		});
+	}
+
+	private void enableIntroductionActionIfAvailable(final MenuItem item) {
+		runOnDbThread(new Runnable() {
+			@Override
+			public void run() {
+				try {
+					if (contactManager.getActiveContacts().size() > 1) {
+						enableIntroductionAction(item);
+						Settings settings =
+								settingsManager.getSettings(SETTINGS_NAMESPACE);
+						if (settings.getBoolean(SHOW_ONBOARDING_INTRODUCTION,
+								true)) {
+							showIntroductionOnboarding();
+						}
+					}
+				} catch (DbException e) {
+					if (LOG.isLoggable(WARNING))
+						LOG.log(WARNING, e.toString(), e);
+				}
+			}
+		});
+	}
+
+	private void enableIntroductionAction(final MenuItem item) {
+		runOnUiThreadUnlessDestroyed(new Runnable() {
+			@Override
+			public void run() {
+				item.setEnabled(true);
+			}
+		});
+	}
+
+	private void showIntroductionOnboarding() {
+		runOnUiThreadUnlessDestroyed(new Runnable() {
+			@Override
+			public void run() {
+				// find view of overflow icon
+				View target = null;
+				for (int i = 0; i < toolbar.getChildCount(); i++) {
+					if (toolbar.getChildAt(i) instanceof ActionMenuView) {
+						ActionMenuView menu =
+								(ActionMenuView) toolbar.getChildAt(i);
+						target = menu.getChildAt(menu.getChildCount() - 1);
+						break;
+					}
+				}
+				if (target == null) {
+					LOG.warning("No Overflow Icon found!");
+					return;
+				}
+
+				OnHidePromptListener listener = new OnHidePromptListener() {
+					@Override
+					public void onHidePrompt(MotionEvent motionEvent,
+							boolean focalClicked) {
+						introductionOnboardingSeen();
+					}
+
+					@Override
+					public void onHidePromptComplete() {
+					}
+				};
+				new MaterialTapTargetPrompt.Builder(ConversationActivity.this)
+						.setTarget(target)
+						.setPrimaryText(R.string.introduction_onboarding_title)
+						.setSecondaryText(R.string.introduction_onboarding_text)
+						.setBackgroundColourFromRes(R.color.briar_primary)
+						.setIcon(R.drawable.ic_more_vert_accent)
+						.setOnHidePromptListener(listener)
+						.show();
+			}
+		});
+	}
+
+	private void introductionOnboardingSeen() {
+		runOnDbThread(new Runnable() {
+			@Override
+			public void run() {
+				try {
+					Settings settings = new Settings();
+					settings.putBoolean(SHOW_ONBOARDING_INTRODUCTION, false);
+					settingsManager.mergeSettings(settings, SETTINGS_NAMESPACE);
+				} catch (DbException e) {
+					if (LOG.isLoggable(WARNING))
+						LOG.log(WARNING, e.toString(), e);
+				}
+			}
+		});
+	}
+
+	@Override
+	public void onItemVisible(ConversationItem item) {
+		if (!item.isRead()) markMessageRead(item.getGroupId(), item.getId());
+	}
+
+	private void markMessageRead(final GroupId g, final MessageId m) {
+		runOnDbThread(new Runnable() {
+			@Override
+			public void run() {
+				try {
+					long now = System.currentTimeMillis();
+					messagingManager.setReadFlag(g, m, true);
+					long duration = System.currentTimeMillis() - now;
+					if (LOG.isLoggable(INFO))
+						LOG.info("Marking read took " + duration + " ms");
+				} catch (DbException e) {
+					if (LOG.isLoggable(WARNING))
+						LOG.log(WARNING, e.toString(), e);
+				}
+			}
+		});
+	}
+
+	@UiThread
+	@Override
+	public void respondToRequest(final ConversationRequestItem item,
+			final boolean accept) {
+		int position = adapter.findItemPosition(item);
+		if (position != INVALID_POSITION) {
+			adapter.notifyItemChanged(position, item);
+		}
+		runOnDbThread(new Runnable() {
+			@Override
+			public void run() {
+				long timestamp = System.currentTimeMillis();
+				timestamp = Math.max(timestamp, getMinTimestampForNewMessage());
+				try {
+					switch (item.getRequestType()) {
+						case INTRODUCTION:
+							respondToIntroductionRequest(item.getSessionId(),
+									accept, timestamp);
+							break;
+						case FORUM:
+							respondToForumRequest(item.getSessionId(), accept);
+							break;
+						case BLOG:
+							respondToBlogRequest(item.getSessionId(), accept);
+							break;
+						case GROUP:
+							respondToGroupRequest(item.getSessionId(), accept);
+							break;
+						default:
+							throw new IllegalArgumentException(
+									"Unknown Request Type");
+					}
+					loadMessages();
+				} catch (DbException | FormatException e) {
+					introductionResponseError();
+					if (LOG.isLoggable(WARNING))
+						LOG.log(WARNING, e.toString(), e);
+				}
+
+			}
+		});
+	}
+
+	@DatabaseExecutor
+	private void respondToIntroductionRequest(SessionId sessionId,
+			boolean accept, long time) throws DbException, FormatException {
+		if (accept) {
+			introductionManager.acceptIntroduction(contactId, sessionId, time);
+		} else {
+			introductionManager.declineIntroduction(contactId, sessionId, time);
+		}
+	}
+
+	@DatabaseExecutor
+	private void respondToForumRequest(SessionId id, boolean accept)
+			throws DbException {
+		forumSharingManager.respondToInvitation(id, accept);
+	}
+
+	@DatabaseExecutor
+	private void respondToBlogRequest(SessionId id, boolean accept)
+			throws DbException {
+		blogSharingManager.respondToInvitation(id, accept);
+	}
+
+	@DatabaseExecutor
+	private void respondToGroupRequest(SessionId id, boolean accept)
+			throws DbException {
+		try {
+			groupInvitationManager.respondToInvitation(contactId, id, accept);
+		} catch (ProtocolStateException e) {
+			// this action is no longer possible
+		}
+	}
+
+	private void introductionResponseError() {
+		runOnUiThreadUnlessDestroyed(new Runnable() {
+			@Override
+			public void run() {
+				Toast.makeText(ConversationActivity.this,
+						R.string.introduction_response_error,
+						Toast.LENGTH_SHORT).show();
+			}
+		});
+	}
+
+}

briar-android/src/main/java/org/briarproject/briar/android/contact/ConversationAdapter.java

@@ -0,0 +1,144 @@
+package org.briarproject.briar.android.contact;
+
+import android.content.Context;
+import android.support.annotation.LayoutRes;
+import android.support.annotation.UiThread;
+import android.util.SparseArray;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+
+import org.briarproject.bramble.api.nullsafety.NotNullByDefault;
+import org.briarproject.briar.R;
+import org.briarproject.briar.android.util.BriarAdapter;
+
+import javax.annotation.Nullable;
+
+class ConversationAdapter
+		extends BriarAdapter<ConversationItem, ConversationItemViewHolder> {
+
+	private ConversationListener listener;
+
+	ConversationAdapter(Context ctx, ConversationListener conversationListener) {
+		super(ctx, ConversationItem.class);
+		listener = conversationListener;
+	}
+
+	@LayoutRes
+	@Override
+	public int getItemViewType(int position) {
+		ConversationItem item = items.get(position);
+		return item.getLayout();
+	}
+
+	@Override
+	public ConversationItemViewHolder onCreateViewHolder(ViewGroup viewGroup,
+			@LayoutRes int type) {
+		View v = LayoutInflater.from(viewGroup.getContext()).inflate(
+				type, viewGroup, false);
+		switch (type) {
+			case R.layout.list_item_conversation_msg_in:
+				return new ConversationItemViewHolder(v);
+			case R.layout.list_item_conversation_msg_out:
+				return new ConversationMessageOutViewHolder(v);
+			case R.layout.list_item_conversation_notice_in:
+				return new ConversationNoticeInViewHolder(v);
+			case R.layout.list_item_conversation_notice_out:
+				return new ConversationNoticeOutViewHolder(v);
+			case R.layout.list_item_conversation_request:
+				return new ConversationRequestViewHolder(v);
+			default:
+				throw new IllegalArgumentException("Unknown ConversationItem");
+		}
+	}
+
+	@Override
+	public void onBindViewHolder(ConversationItemViewHolder ui, int position) {
+		ConversationItem item = items.get(position);
+		if (item instanceof ConversationRequestItem) {
+			((ConversationRequestViewHolder) ui).bind(item, listener);
+		} else {
+			ui.bind(item);
+		}
+		listener.onItemVisible(item);
+	}
+
+	@Override
+	public int compare(ConversationItem c1,
+			ConversationItem c2) {
+		long time1 = c1.getTime();
+		long time2 = c2.getTime();
+		if (time1 < time2) return -1;
+		if (time1 > time2) return 1;
+		return 0;
+	}
+
+	@Override
+	public boolean areItemsTheSame(ConversationItem c1,
+			ConversationItem c2) {
+		return c1.getId().equals(c2.getId());
+	}
+
+	@Override
+	public boolean areContentsTheSame(ConversationItem c1,
+			ConversationItem c2) {
+		return c1.equals(c2);
+	}
+
+	@Nullable
+	ConversationItem getLastItem() {
+		if (items.size() > 0) {
+			return items.get(items.size() - 1);
+		} else {
+			return null;
+		}
+	}
+
+	SparseArray<ConversationItem> getIncomingMessages() {
+		SparseArray<ConversationItem> messages = new SparseArray<>();
+
+		for (int i = 0; i < items.size(); i++) {
+			ConversationItem item = items.get(i);
+			if (item.isIncoming()) {
+				messages.put(i, item);
+			}
+		}
+		return messages;
+	}
+
+	SparseArray<ConversationOutItem> getOutgoingMessages() {
+		SparseArray<ConversationOutItem> messages = new SparseArray<>();
+
+		for (int i = 0; i < items.size(); i++) {
+			ConversationItem item = items.get(i);
+			if (item instanceof ConversationOutItem) {
+				messages.put(i, (ConversationOutItem) item);
+			}
+		}
+		return messages;
+	}
+
+	SparseArray<ConversationItem> getPrivateMessages() {
+		SparseArray<ConversationItem> messages = new SparseArray<>();
+
+		for (int i = 0; i < items.size(); i++) {
+			ConversationItem item = items.get(i);
+			if (item instanceof ConversationMessageInItem) {
+				messages.put(i, item);
+			} else if (item instanceof ConversationMessageOutItem) {
+				messages.put(i, item);
+			}
+		}
+		return messages;
+	}
+
+	@UiThread
+	@NotNullByDefault
+	interface ConversationListener {
+
+		void onItemVisible(ConversationItem item);
+
+		void respondToRequest(ConversationRequestItem item, boolean accept);
+	}
+
+}

briar-android/src/main/java/org/briarproject/briar/android/contact/ConversationItem.java

@@ -0,0 +1,298 @@
+package org.briarproject.briar.android.contact;
+
+import android.content.Context;
+import android.support.annotation.LayoutRes;
+import android.support.annotation.StringRes;
+
+import org.briarproject.bramble.api.nullsafety.NotNullByDefault;
+import org.briarproject.bramble.api.sync.GroupId;
+import org.briarproject.bramble.api.sync.MessageId;
+import org.briarproject.briar.R;
+import org.briarproject.briar.android.contact.ConversationRequestItem.RequestType;
+import org.briarproject.briar.api.blog.BlogInvitationRequest;
+import org.briarproject.briar.api.blog.BlogInvitationResponse;
+import org.briarproject.briar.api.client.BaseMessageHeader;
+import org.briarproject.briar.api.forum.ForumInvitationRequest;
+import org.briarproject.briar.api.forum.ForumInvitationResponse;
+import org.briarproject.briar.api.introduction.IntroductionRequest;
+import org.briarproject.briar.api.introduction.IntroductionResponse;
+import org.briarproject.briar.api.messaging.PrivateMessageHeader;
+import org.briarproject.briar.api.privategroup.invitation.GroupInvitationRequest;
+import org.briarproject.briar.api.privategroup.invitation.GroupInvitationResponse;
+import org.briarproject.briar.api.sharing.InvitationRequest;
+import org.briarproject.briar.api.sharing.InvitationResponse;
+
+import javax.annotation.Nullable;
+import javax.annotation.concurrent.NotThreadSafe;
+
+import static org.briarproject.briar.android.contact.ConversationRequestItem.RequestType.BLOG;
+import static org.briarproject.briar.android.contact.ConversationRequestItem.RequestType.FORUM;
+import static org.briarproject.briar.android.contact.ConversationRequestItem.RequestType.GROUP;
+import static org.briarproject.briar.android.contact.ConversationRequestItem.RequestType.INTRODUCTION;
+
+@NotThreadSafe
+@NotNullByDefault
+abstract class ConversationItem {
+
+	protected @Nullable String body;
+	private final MessageId id;
+	private final GroupId groupId;
+	private final long time;
+	private boolean read;
+
+	ConversationItem(MessageId id, GroupId groupId, @Nullable String body,
+			long time, boolean read) {
+		this.id = id;
+		this.groupId = groupId;
+		this.body = body;
+		this.time = time;
+		this.read = read;
+	}
+
+	MessageId getId() {
+		return id;
+	}
+
+	GroupId getGroupId() {
+		return groupId;
+	}
+
+	void setBody(String body) {
+		this.body = body;
+	}
+
+	@Nullable
+	public String getBody() {
+		return body;
+	}
+
+	long getTime() {
+		return time;
+	}
+
+	public boolean isRead() {
+		return read;
+	}
+
+	abstract public boolean isIncoming();
+
+	@LayoutRes
+	abstract public int getLayout();
+
+	static ConversationItem from(PrivateMessageHeader h) {
+		if (h.isLocal()) {
+			return new ConversationMessageOutItem(h);
+		} else {
+			return new ConversationMessageInItem(h);
+		}
+	}
+
+	static ConversationItem from(Context ctx, String contactName,
+			IntroductionRequest ir) {
+		if (ir.isLocal()) {
+			String text = ctx.getString(R.string.introduction_request_sent,
+					contactName, ir.getName());
+			return new ConversationNoticeOutItem(ir.getMessageId(),
+					ir.getGroupId(), text, ir.getMessage(), ir.getTimestamp(),
+					ir.isSent(), ir.isSeen());
+		} else {
+			String text;
+			if (ir.wasAnswered()) {
+				text = ctx.getString(
+						R.string.introduction_request_answered_received,
+						contactName, ir.getName());
+				return new ConversationNoticeInItem(ir.getMessageId(),
+						ir.getGroupId(), text, ir.getMessage(), ir.getTimestamp(),
+						ir.isRead());
+			} else if (ir.contactExists()){
+				text = ctx.getString(
+						R.string.introduction_request_exists_received,
+						contactName, ir.getName());
+			} else {
+				text = ctx.getString(R.string.introduction_request_received,
+						contactName, ir.getName());
+			}
+			return new ConversationRequestItem(ir.getMessageId(),
+					ir.getGroupId(), INTRODUCTION, ir.getSessionId(), text,
+					ir.getMessage(), ir.getTimestamp(), ir.isRead(),
+					ir.wasAnswered());
+		}
+	}
+
+	static ConversationItem from(Context ctx, String contactName,
+			IntroductionResponse ir) {
+		if (ir.isLocal()) {
+			String text;
+			if (ir.wasAccepted()) {
+				text = ctx.getString(
+						R.string.introduction_response_accepted_sent,
+						ir.getName());
+			} else {
+				text = ctx.getString(
+						R.string.introduction_response_declined_sent,
+						ir.getName());
+			}
+			return new ConversationNoticeOutItem(ir.getMessageId(),
+					ir.getGroupId(), text, null, ir.getTimestamp(), ir.isSent(),
+					ir.isSeen());
+		} else {
+			String text;
+			if (ir.wasAccepted()) {
+				text = ctx.getString(
+						R.string.introduction_response_accepted_received,
+						contactName, ir.getName());
+			} else {
+				if (ir.isIntroducer()) {
+					text = ctx.getString(
+							R.string.introduction_response_declined_received,
+							contactName, ir.getName());
+				} else {
+					text = ctx.getString(
+							R.string.introduction_response_declined_received_by_introducee,
+							contactName, ir.getName());
+				}
+			}
+			return new ConversationNoticeInItem(ir.getMessageId(),
+					ir.getGroupId(), text, null, ir.getTimestamp(),
+					ir.isRead());
+		}
+	}
+
+	static ConversationItem from(Context ctx, String contactName,
+			InvitationRequest ir) {
+		if (ir.isLocal()) {
+			String text;
+			if (ir instanceof ForumInvitationRequest) {
+				text = ctx.getString(R.string.forum_invitation_sent,
+						((ForumInvitationRequest) ir).getForumName(),
+						contactName);
+			} else if (ir instanceof BlogInvitationRequest) {
+				text = ctx.getString(R.string.blogs_sharing_invitation_sent,
+						((BlogInvitationRequest) ir).getBlogAuthorName(),
+						contactName);
+			} else if (ir instanceof GroupInvitationRequest) {
+				text = ctx.getString(
+						R.string.groups_invitations_invitation_sent,
+						contactName,
+						((GroupInvitationRequest) ir).getGroupName());
+			} else {
+				throw new IllegalArgumentException("Unknown InvitationRequest");
+			}
+			return new ConversationNoticeOutItem(ir.getId(), ir.getGroupId(),
+					text, ir.getMessage(), ir.getTimestamp(), ir.isSent(),
+					ir.isSeen());
+		} else {
+			String text;
+			RequestType type;
+			if (ir instanceof ForumInvitationRequest) {
+				text = ctx.getString(R.string.forum_invitation_received,
+						contactName,
+						((ForumInvitationRequest) ir).getForumName());
+				type = FORUM;
+			} else if (ir instanceof BlogInvitationRequest) {
+				text = ctx.getString(R.string.blogs_sharing_invitation_received,
+						contactName,
+						((BlogInvitationRequest) ir).getBlogAuthorName());
+				type = BLOG;
+			} else if (ir instanceof GroupInvitationRequest) {
+				text = ctx.getString(
+						R.string.groups_invitations_invitation_received,
+						contactName,
+						((GroupInvitationRequest) ir).getGroupName());
+				type = GROUP;
+			} else {
+				throw new IllegalArgumentException("Unknown InvitationRequest");
+			}
+			if (!ir.isAvailable()) {
+				return new ConversationNoticeInItem(ir.getId(), ir.getGroupId(),
+						text, ir.getMessage(), ir.getTimestamp(), ir.isRead());
+			}
+			return new ConversationRequestItem(ir.getId(),
+					ir.getGroupId(), type, ir.getSessionId(), text,
+					ir.getMessage(), ir.getTimestamp(), ir.isRead(),
+					!ir.isAvailable());
+		}
+	}
+
+	static ConversationItem from(Context ctx, String contactName,
+			InvitationResponse ir) {
+		@StringRes int res;
+		if (ir.isLocal()) {
+			if (ir.wasAccepted()) {
+				if (ir instanceof ForumInvitationResponse) {
+					res = R.string.forum_invitation_response_accepted_sent;
+				} else if (ir instanceof BlogInvitationResponse) {
+					res = R.string.blogs_sharing_response_accepted_sent;
+				} else if (ir instanceof GroupInvitationResponse) {
+					res = R.string.groups_invitations_response_accepted_sent;
+				} else {
+					throw new IllegalArgumentException(
+							"Unknown InvitationResponse");
+				}
+			} else {
+				if (ir instanceof ForumInvitationResponse) {
+					res = R.string.forum_invitation_response_declined_sent;
+				} else if (ir instanceof BlogInvitationResponse) {
+					res = R.string.blogs_sharing_response_declined_sent;
+				} else if (ir instanceof GroupInvitationResponse) {
+					res = R.string.groups_invitations_response_declined_sent;
+				} else {
+					throw new IllegalArgumentException(
+							"Unknown InvitationResponse");
+				}
+			}
+			String text = ctx.getString(res, contactName);
+			return new ConversationNoticeOutItem(ir.getId(), ir.getGroupId(),
+					text, null, ir.getTimestamp(), ir.isSent(), ir.isSeen());
+		} else {
+			if (ir.wasAccepted()) {
+				if (ir instanceof ForumInvitationResponse) {
+					res = R.string.forum_invitation_response_accepted_received;
+				} else if (ir instanceof BlogInvitationResponse) {
+					res = R.string.blogs_sharing_response_accepted_received;
+				} else if (ir instanceof GroupInvitationResponse) {
+					res = R.string.groups_invitations_response_accepted_received;
+				} else {
+					throw new IllegalArgumentException(
+							"Unknown InvitationResponse");
+				}
+			} else {
+					if (ir instanceof ForumInvitationResponse) {
+						res = R.string.forum_invitation_response_declined_received;
+					} else if (ir instanceof BlogInvitationResponse) {
+						res = R.string.blogs_sharing_response_declined_received;
+					} else if (ir instanceof GroupInvitationResponse) {
+						res = R.string.groups_invitations_response_declined_received;
+					} else {
+						throw new IllegalArgumentException(
+								"Unknown InvitationResponse");
+					}
+			}
+			String text = ctx.getString(res, contactName);
+			return new ConversationNoticeInItem(ir.getId(), ir.getGroupId(),
+					text, null, ir.getTimestamp(), ir.isRead());
+		}
+	}
+
+	/**
+	 * This method should not be used to display the resulting ConversationItem
+	 * in the UI, but only to update list information based on the
+	 * BaseMessageHeader.
+	 **/
+	static ConversationItem from(Context ctx, BaseMessageHeader h) {
+		if (h instanceof PrivateMessageHeader) {
+			return from((PrivateMessageHeader) h);
+		} else if(h instanceof IntroductionRequest) {
+			return from(ctx, "", (IntroductionRequest) h);
+		} else if(h instanceof IntroductionResponse) {
+			return from(ctx, "", (IntroductionResponse) h);
+		} else if(h instanceof InvitationRequest) {
+			return from(ctx, "", (InvitationRequest) h);
+		} else if(h instanceof InvitationResponse) {
+			return from(ctx, "", (InvitationResponse) h);
+		} else {
+			throw new IllegalArgumentException("Unknown message header");
+		}
+	}
+
+}

briar-android/src/main/java/org/briarproject/briar/android/contact/ConversationItemViewHolder.java

@@ -0,0 +1,42 @@
+package org.briarproject.briar.android.contact;
+
+import android.support.annotation.CallSuper;
+import android.support.annotation.UiThread;
+import android.support.v7.widget.RecyclerView.ViewHolder;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.TextView;
+
+import org.briarproject.bramble.api.nullsafety.NotNullByDefault;
+import org.briarproject.bramble.util.StringUtils;
+import org.briarproject.briar.R;
+import org.briarproject.briar.android.util.UiUtils;
+
+@UiThread
+@NotNullByDefault
+class ConversationItemViewHolder extends ViewHolder {
+
+	protected final ViewGroup layout;
+	private final TextView text;
+	private final TextView time;
+
+	ConversationItemViewHolder(View v) {
+		super(v);
+		layout = (ViewGroup) v.findViewById(R.id.layout);
+		text = (TextView) v.findViewById(R.id.text);
+		time = (TextView) v.findViewById(R.id.time);
+	}
+
+	@CallSuper
+	void bind(ConversationItem item) {
+		if (item.getBody() == null) {
+			text.setText("\u2026");
+		} else {
+			text.setText(StringUtils.trim(item.getBody()));
+		}
+
+		long timestamp = item.getTime();
+		time.setText(UiUtils.formatDate(time.getContext(), timestamp));
+	}
+
+}

briar-android/src/main/java/org/briarproject/briar/android/contact/ConversationMessageInItem.java

@@ -0,0 +1,30 @@
+package org.briarproject.briar.android.contact;
+
+import android.support.annotation.LayoutRes;
+
+import org.briarproject.bramble.api.nullsafety.NotNullByDefault;
+import org.briarproject.briar.R;
+import org.briarproject.briar.api.messaging.PrivateMessageHeader;
+
+import javax.annotation.concurrent.NotThreadSafe;
+
+@NotThreadSafe
+@NotNullByDefault
+class ConversationMessageInItem extends ConversationItem {
+
+	ConversationMessageInItem(PrivateMessageHeader h) {
+		super(h.getId(), h.getGroupId(), null, h.getTimestamp(), h.isRead());
+	}
+
+	@Override
+	public boolean isIncoming() {
+		return true;
+	}
+
+	@LayoutRes
+	@Override
+	public int getLayout() {
+		return R.layout.list_item_conversation_msg_in;
+	}
+
+}

briar-android/src/main/java/org/briarproject/briar/android/contact/ConversationMessageOutItem.java

@@ -0,0 +1,26 @@
+package org.briarproject.briar.android.contact;
+
+import android.support.annotation.LayoutRes;
+
+import org.briarproject.bramble.api.nullsafety.NotNullByDefault;
+import org.briarproject.briar.R;
+import org.briarproject.briar.api.messaging.PrivateMessageHeader;
+
+import javax.annotation.concurrent.NotThreadSafe;
+
+@NotThreadSafe
+@NotNullByDefault
+class ConversationMessageOutItem extends ConversationOutItem {
+
+	ConversationMessageOutItem(PrivateMessageHeader h) {
+		super(h.getId(), h.getGroupId(), null, h.getTimestamp(), h.isSent(),
+				h.isSeen());
+	}
+
+	@LayoutRes
+	@Override
+	public int getLayout() {
+		return R.layout.list_item_conversation_msg_out;
+	}
+
+}

briar-android/src/main/java/org/briarproject/briar/android/contact/ConversationMessageOutViewHolder.java

@@ -0,0 +1,16 @@
+package org.briarproject.briar.android.contact;
+
+import android.view.View;
+
+class ConversationMessageOutViewHolder extends ConversationOutItemViewHolder {
+
+	ConversationMessageOutViewHolder(View v) {
+		super(v);
+	}
+
+	@Override
+	protected boolean hasDarkBackground() {
+		return true;
+	}
+
+}

briar-android/src/main/java/org/briarproject/briar/android/contact/ConversationNoticeInItem.java

@@ -0,0 +1,43 @@
+package org.briarproject.briar.android.contact;
+
+import android.support.annotation.LayoutRes;
+
+import org.briarproject.bramble.api.nullsafety.NotNullByDefault;
+import org.briarproject.bramble.api.sync.GroupId;
+import org.briarproject.bramble.api.sync.MessageId;
+import org.briarproject.briar.R;
+
+import javax.annotation.Nullable;
+import javax.annotation.concurrent.NotThreadSafe;
+
+@NotThreadSafe
+@NotNullByDefault
+class ConversationNoticeInItem extends ConversationItem {
+
+	@Nullable
+	private final String msgText;
+
+	ConversationNoticeInItem(MessageId id, GroupId groupId,
+			String text, @Nullable String msgText, long time,
+			boolean read) {
+		super(id, groupId, text, time, read);
+		this.msgText = msgText;
+	}
+
+	@Nullable
+	String getMsgText() {
+		return msgText;
+	}
+
+	@Override
+	public boolean isIncoming() {
+		return true;
+	}
+
+	@LayoutRes
+	@Override
+	public int getLayout() {
+		return R.layout.list_item_conversation_notice_in;
+	}
+
+}

briar-android/src/main/java/org/briarproject/briar/android/contact/ConversationNoticeInViewHolder.java

@@ -0,0 +1,43 @@
+package org.briarproject.briar.android.contact;
+
+import android.support.annotation.UiThread;
+import android.view.View;
+import android.widget.TextView;
+
+import org.briarproject.bramble.api.nullsafety.NotNullByDefault;
+import org.briarproject.bramble.util.StringUtils;
+import org.briarproject.briar.R;
+
+import static android.view.View.GONE;
+import static android.view.View.VISIBLE;
+
+@UiThread
+@NotNullByDefault
+class ConversationNoticeInViewHolder extends ConversationItemViewHolder {
+
+	private final TextView msgText;
+
+	ConversationNoticeInViewHolder(View v) {
+		super(v);
+		msgText = (TextView) v.findViewById(R.id.msgText);
+	}
+
+	@Override
+	void bind(ConversationItem conversationItem) {
+		super.bind(conversationItem);
+
+		ConversationNoticeInItem item =
+				(ConversationNoticeInItem) conversationItem;
+
+		String message = item.getMsgText();
+		if (StringUtils.isNullOrEmpty(message)) {
+			msgText.setVisibility(GONE);
+			layout.setBackgroundResource(R.drawable.notice_in);
+		} else {
+			msgText.setVisibility(VISIBLE);
+			msgText.setText(StringUtils.trim(message));
+			layout.setBackgroundResource(R.drawable.notice_in_bottom);
+		}
+	}
+
+}

briar-android/src/main/java/org/briarproject/briar/android/contact/ConversationNoticeOutItem.java

@@ -0,0 +1,38 @@
+package org.briarproject.briar.android.contact;
+
+import android.support.annotation.LayoutRes;
+
+import org.briarproject.bramble.api.nullsafety.NotNullByDefault;
+import org.briarproject.bramble.api.sync.GroupId;
+import org.briarproject.bramble.api.sync.MessageId;
+import org.briarproject.briar.R;
+
+import javax.annotation.Nullable;
+import javax.annotation.concurrent.NotThreadSafe;
+
+@NotThreadSafe
+@NotNullByDefault
+class ConversationNoticeOutItem extends ConversationOutItem {
+
+	@Nullable
+	private final String msgText;
+
+	ConversationNoticeOutItem(MessageId id, GroupId groupId,
+			String text, @Nullable String msgText, long time,
+			boolean sent, boolean seen) {
+		super(id, groupId, text, time, sent, seen);
+		this.msgText = msgText;
+	}
+
+	@Nullable
+	String getMsgText() {
+		return msgText;
+	}
+
+	@LayoutRes
+	@Override
+	public int getLayout() {
+		return R.layout.list_item_conversation_notice_out;
+	}
+
+}

briar-android/src/main/java/org/briarproject/briar/android/contact/ConversationNoticeOutViewHolder.java

@@ -0,0 +1,48 @@
+package org.briarproject.briar.android.contact;
+
+import android.support.annotation.UiThread;
+import android.view.View;
+import android.widget.TextView;
+
+import org.briarproject.bramble.api.nullsafety.NotNullByDefault;
+import org.briarproject.bramble.util.StringUtils;
+import org.briarproject.briar.R;
+
+import static android.view.View.GONE;
+import static android.view.View.VISIBLE;
+
+@UiThread
+@NotNullByDefault
+class ConversationNoticeOutViewHolder extends ConversationOutItemViewHolder {
+
+	private final TextView msgText;
+
+	ConversationNoticeOutViewHolder(View v) {
+		super(v);
+		msgText = (TextView) v.findViewById(R.id.msgText);
+	}
+
+	@Override
+	void bind(ConversationItem conversationItem) {
+		super.bind(conversationItem);
+
+		ConversationNoticeOutItem item =
+				(ConversationNoticeOutItem) conversationItem;
+
+		String message = item.getMsgText();
+		if (StringUtils.isNullOrEmpty(message)) {
+			msgText.setVisibility(GONE);
+			layout.setBackgroundResource(R.drawable.notice_out);
+		} else {
+			msgText.setVisibility(VISIBLE);
+			msgText.setText(StringUtils.trim(message));
+			layout.setBackgroundResource(R.drawable.notice_out_bottom);
+		}
+	}
+
+	@Override
+	protected boolean hasDarkBackground() {
+		return false;
+	}
+
+}

briar-android/src/main/java/org/briarproject/briar/android/contact/ConversationOutItem.java

@@ -0,0 +1,45 @@
+package org.briarproject.briar.android.contact;
+
+import org.briarproject.bramble.api.nullsafety.NotNullByDefault;
+import org.briarproject.bramble.api.sync.GroupId;
+import org.briarproject.bramble.api.sync.MessageId;
+
+import javax.annotation.Nullable;
+import javax.annotation.concurrent.NotThreadSafe;
+
+@NotThreadSafe
+@NotNullByDefault
+abstract class ConversationOutItem extends ConversationItem {
+
+	private boolean sent, seen;
+
+	ConversationOutItem(MessageId id, GroupId groupId, @Nullable String text,
+			long time, boolean sent, boolean seen) {
+		super(id, groupId, text, time, true);
+
+		this.sent = sent;
+		this.seen = seen;
+	}
+
+	boolean isSent() {
+		return sent;
+	}
+
+	void setSent(boolean sent) {
+		this.sent = sent;
+	}
+
+	boolean isSeen() {
+		return seen;
+	}
+
+	void setSeen(boolean seen) {
+		this.seen = seen;
+	}
+
+	@Override
+	public boolean isIncoming() {
+		return false;
+	}
+
+}

briar-android/src/main/java/org/briarproject/briar/android/contact/ConversationOutItemViewHolder.java

@@ -0,0 +1,44 @@
+package org.briarproject.briar.android.contact;
+
+import android.support.annotation.UiThread;
+import android.view.View;
+import android.widget.ImageView;
+
+import org.briarproject.bramble.api.nullsafety.NotNullByDefault;
+import org.briarproject.briar.R;
+
+@UiThread
+@NotNullByDefault
+abstract class ConversationOutItemViewHolder
+		extends ConversationItemViewHolder {
+
+	private final ImageView status;
+
+	ConversationOutItemViewHolder(View v) {
+		super(v);
+		status = (ImageView) v.findViewById(R.id.status);
+	}
+
+	@Override
+	void bind(ConversationItem conversationItem) {
+		super.bind(conversationItem);
+
+		ConversationOutItem item = (ConversationOutItem) conversationItem;
+
+		int res;
+		if (item.isSeen()) {
+			if (hasDarkBackground()) res = R.drawable.message_delivered_white;
+			else res = R.drawable.message_delivered;
+		} else if (item.isSent()) {
+			if (hasDarkBackground()) res = R.drawable.message_sent_white;
+			else res = R.drawable.message_sent;
+		} else {
+			if (hasDarkBackground()) res = R.drawable.message_stored_white;
+			else res = R.drawable.message_stored;
+		}
+		status.setImageResource(res);
+	}
+
+	protected abstract boolean hasDarkBackground();
+
+}

briar-android/src/main/java/org/briarproject/briar/android/contact/ConversationRequestItem.java

@@ -0,0 +1,56 @@
+package org.briarproject.briar.android.contact;
+
+import android.support.annotation.LayoutRes;
+
+import org.briarproject.bramble.api.nullsafety.NotNullByDefault;
+import org.briarproject.bramble.api.sync.GroupId;
+import org.briarproject.bramble.api.sync.MessageId;
+import org.briarproject.briar.R;
+import org.briarproject.briar.api.client.SessionId;
+
+import javax.annotation.Nullable;
+import javax.annotation.concurrent.NotThreadSafe;
+
+@NotThreadSafe
+@NotNullByDefault
+class ConversationRequestItem extends ConversationNoticeInItem {
+
+	enum RequestType { INTRODUCTION, FORUM, BLOG, GROUP }
+
+	private final RequestType requestType;
+	private final SessionId sessionId;
+	private boolean answered;
+
+	ConversationRequestItem(MessageId id, GroupId groupId,
+			RequestType requestType, SessionId sessionId, String text,
+			@Nullable String msgText, long time, boolean read,
+			boolean answered) {
+		super(id, groupId, text, msgText, time, read);
+		this.requestType = requestType;
+		this.sessionId = sessionId;
+		this.answered = answered;
+	}
+
+	RequestType getRequestType() {
+		return requestType;
+	}
+
+	SessionId getSessionId() {
+		return sessionId;
+	}
+
+	boolean wasAnswered() {
+		return answered;
+	}
+
+	void setAnswered(boolean answered) {
+		this.answered = answered;
+	}
+
+	@LayoutRes
+	@Override
+	public int getLayout() {
+		return R.layout.list_item_conversation_request;
+	}
+
+}

briar-android/src/main/java/org/briarproject/briar/android/contact/ConversationRequestViewHolder.java

@@ -0,0 +1,58 @@
+package org.briarproject.briar.android.contact;
+
+import android.support.annotation.UiThread;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.widget.Button;
+
+import org.briarproject.bramble.api.nullsafety.NotNullByDefault;
+import org.briarproject.briar.R;
+import org.briarproject.briar.android.contact.ConversationAdapter.ConversationListener;
+
+import static android.view.View.GONE;
+import static android.view.View.VISIBLE;
+
+@UiThread
+@NotNullByDefault
+class ConversationRequestViewHolder extends ConversationNoticeInViewHolder {
+
+	private final Button acceptButton;
+	private final Button declineButton;
+
+	ConversationRequestViewHolder(View v) {
+		super(v);
+		acceptButton = (Button) v.findViewById(R.id.acceptButton);
+		declineButton = (Button) v.findViewById(R.id.declineButton);
+	}
+
+	void bind(ConversationItem conversationItem,
+			final ConversationListener listener) {
+		super.bind(conversationItem);
+
+		final ConversationRequestItem item =
+				(ConversationRequestItem) conversationItem;
+
+		if (item.wasAnswered()) {
+			acceptButton.setVisibility(GONE);
+			declineButton.setVisibility(GONE);
+		} else {
+			acceptButton.setVisibility(VISIBLE);
+			acceptButton.setOnClickListener(new OnClickListener() {
+				@Override
+				public void onClick(View v) {
+					item.setAnswered(true);
+					listener.respondToRequest(item, true);
+				}
+			});
+			declineButton.setVisibility(VISIBLE);
+			declineButton.setOnClickListener(new OnClickListener() {
+				@Override
+				public void onClick(View v) {
+					item.setAnswered(true);
+					listener.respondToRequest(item, false);
+				}
+			});
+		}
+	}
+
+}

briar-android/src/main/java/org/briarproject/briar/android/contactselection/BaseContactSelectorAdapter.java

@@ -0,0 +1,32 @@
+package org.briarproject.briar.android.contactselection;
+
+import android.content.Context;
+
+import org.briarproject.bramble.api.contact.ContactId;
+import org.briarproject.bramble.api.nullsafety.NotNullByDefault;
+import org.briarproject.briar.android.contact.BaseContactListAdapter;
+import org.briarproject.briar.android.contact.ContactItemViewHolder;
+
+import java.util.ArrayList;
+import java.util.Collection;
+
+@NotNullByDefault
+public abstract class BaseContactSelectorAdapter<I extends SelectableContactItem, H extends ContactItemViewHolder<I>>
+		extends BaseContactListAdapter<I, H> {
+
+	public BaseContactSelectorAdapter(Context context, Class<I> c,
+			OnContactClickListener<I> listener) {
+		super(context, c, listener);
+	}
+
+	public Collection<ContactId> getSelectedContactIds() {
+		Collection<ContactId> selected = new ArrayList<>();
+
+		for (int i = 0; i < items.size(); i++) {
+			SelectableContactItem item = items.get(i);
+			if (item.isSelected()) selected.add(item.getContact().getId());
+		}
+		return selected;
+	}
+
+}

briar-android/src/main/java/org/briarproject/briar/android/contactselection/BaseContactSelectorFragment.java

@@ -0,0 +1,149 @@
+package org.briarproject.briar.android.contactselection;
+
+import android.content.Context;
+import android.os.Build;
+import android.os.Bundle;
+import android.support.annotation.CallSuper;
+import android.support.v7.widget.LinearLayoutManager;
+import android.transition.Fade;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+
+import org.briarproject.bramble.api.contact.ContactId;
+import org.briarproject.bramble.api.db.DbException;
+import org.briarproject.bramble.api.nullsafety.MethodsNotNullByDefault;
+import org.briarproject.bramble.api.nullsafety.ParametersNotNullByDefault;
+import org.briarproject.bramble.api.sync.GroupId;
+import org.briarproject.briar.R;
+import org.briarproject.briar.android.contact.BaseContactListAdapter.OnContactClickListener;
+import org.briarproject.briar.android.contact.ContactItemViewHolder;
+import org.briarproject.briar.android.controller.handler.UiResultExceptionHandler;
+import org.briarproject.briar.android.fragment.BaseFragment;
+import org.briarproject.briar.android.view.BriarRecyclerView;
+
+import java.util.ArrayList;
+import java.util.Collection;
+
+import javax.annotation.Nullable;
+
+import static org.briarproject.briar.android.activity.BriarActivity.GROUP_ID;
+import static org.briarproject.briar.android.contactselection.ContactSelectorActivity.CONTACTS;
+import static org.briarproject.briar.android.contactselection.ContactSelectorActivity.getContactsFromIds;
+import static org.briarproject.briar.android.contactselection.ContactSelectorActivity.getContactsFromIntegers;
+
+@MethodsNotNullByDefault
+@ParametersNotNullByDefault
+public abstract class BaseContactSelectorFragment<I extends SelectableContactItem, A extends BaseContactSelectorAdapter<I, ? extends ContactItemViewHolder<I>>>
+		extends BaseFragment
+		implements OnContactClickListener<I> {
+
+	protected BriarRecyclerView list;
+	protected A adapter;
+	protected Collection<ContactId> selectedContacts = new ArrayList<>();
+	protected ContactSelectorListener listener;
+
+	private GroupId groupId;
+
+	@Override
+	public void onAttach(Context context) {
+		super.onAttach(context);
+		listener = (ContactSelectorListener) context;
+	}
+
+	@Override
+	public void onCreate(Bundle savedInstanceState) {
+		super.onCreate(savedInstanceState);
+
+		Bundle args = getArguments();
+		byte[] b = args.getByteArray(GROUP_ID);
+		if (b == null) throw new IllegalStateException("No GroupId");
+		groupId = new GroupId(b);
+	}
+
+	@Override
+	@CallSuper
+	public View onCreateView(LayoutInflater inflater,
+			@Nullable ViewGroup container,
+			@Nullable Bundle savedInstanceState) {
+
+		View contentView = inflater.inflate(R.layout.list, container, false);
+
+		if (Build.VERSION.SDK_INT >= 21) {
+			setExitTransition(new Fade());
+		}
+
+		list = (BriarRecyclerView) contentView.findViewById(R.id.list);
+		list.setLayoutManager(new LinearLayoutManager(getActivity()));
+		list.setEmptyText(getString(R.string.no_contacts_selector));
+		adapter = getAdapter(getContext(), this);
+		list.setAdapter(adapter);
+
+		// restore selected contacts if available
+		if (savedInstanceState != null) {
+			ArrayList<Integer> intContacts =
+					savedInstanceState.getIntegerArrayList(CONTACTS);
+			if (intContacts != null) {
+				selectedContacts = getContactsFromIntegers(intContacts);
+			}
+		}
+		return contentView;
+	}
+
+	protected abstract A getAdapter(Context context,
+			OnContactClickListener<I> listener);
+
+	@Override
+	public void onStart() {
+		super.onStart();
+		loadContacts(selectedContacts);
+	}
+
+	@Override
+	public void onStop() {
+		super.onStop();
+		adapter.clear();
+		list.showProgressBar();
+	}
+
+	@Override
+	public void onSaveInstanceState(Bundle outState) {
+		super.onSaveInstanceState(outState);
+		if (adapter != null) {
+			selectedContacts = adapter.getSelectedContactIds();
+			outState.putIntegerArrayList(CONTACTS,
+					getContactsFromIds(selectedContacts));
+		}
+	}
+
+	@Override
+	public void onItemClick(View view, I item) {
+		item.toggleSelected();
+		adapter.notifyItemChanged(adapter.findItemPosition(item), item);
+		onSelectionChanged();
+	}
+
+	private void loadContacts(final Collection<ContactId> selection) {
+		getController().loadContacts(groupId, selection,
+				new UiResultExceptionHandler<Collection<I>, DbException>(
+						this) {
+					@Override
+					public void onResultUi(Collection<I> contacts) {
+						if (contacts.isEmpty()) list.showData();
+						else adapter.addAll(contacts);
+						onSelectionChanged();
+					}
+
+					@Override
+					public void onExceptionUi(DbException exception) {
+						// TODO error handling
+						finish();
+					}
+				});
+	}
+
+	protected abstract void onSelectionChanged();
+
+	protected abstract ContactSelectorController<I> getController();
+
+}

briar-android/src/main/java/org/briarproject/briar/android/contactselection/BaseSelectableContactHolder.java

@@ -0,0 +1,59 @@
+package org.briarproject.briar.android.contactselection;
+
+import android.support.annotation.UiThread;
+import android.view.View;
+import android.widget.CheckBox;
+import android.widget.TextView;
+
+import org.briarproject.bramble.api.nullsafety.NotNullByDefault;
+import org.briarproject.briar.R;
+import org.briarproject.briar.android.contact.BaseContactListAdapter.OnContactClickListener;
+import org.briarproject.briar.android.contact.ContactItemViewHolder;
+
+import javax.annotation.Nullable;
+
+import static org.briarproject.briar.android.util.UiUtils.GREY_OUT;
+
+@UiThread
+@NotNullByDefault
+public class BaseSelectableContactHolder<I extends SelectableContactItem>
+		extends ContactItemViewHolder<I> {
+
+	private final CheckBox checkBox;
+	protected final TextView info;
+
+	public BaseSelectableContactHolder(View v) {
+		super(v);
+		checkBox = (CheckBox) v.findViewById(R.id.checkBox);
+		info = (TextView) v.findViewById(R.id.infoView);
+	}
+
+	@Override
+	protected void bind(I item, @Nullable
+			OnContactClickListener<I> listener) {
+		super.bind(item, listener);
+
+		if (item.isSelected()) {
+			checkBox.setChecked(true);
+		} else {
+			checkBox.setChecked(false);
+		}
+
+		if (item.isDisabled()) {
+			layout.setEnabled(false);
+			grayOutItem(true);
+		} else {
+			layout.setEnabled(true);
+			grayOutItem(false);
+		}
+	}
+
+	protected void grayOutItem(boolean gray) {
+		float alpha = gray ? GREY_OUT : 1f;
+		avatar.setAlpha(alpha);
+		name.setAlpha(alpha);
+		checkBox.setAlpha(alpha);
+		info.setAlpha(alpha);
+	}
+
+}

briar-android/src/main/java/org/briarproject/briar/android/contactselection/ContactSelectorActivity.java

@@ -0,0 +1,109 @@
+package org.briarproject.briar.android.contactselection;
+
+import android.os.Build;
+import android.os.Bundle;
+import android.support.annotation.CallSuper;
+import android.support.annotation.LayoutRes;
+import android.support.annotation.UiThread;
+import android.transition.Fade;
+
+import org.briarproject.bramble.api.contact.ContactId;
+import org.briarproject.bramble.api.nullsafety.MethodsNotNullByDefault;
+import org.briarproject.bramble.api.nullsafety.ParametersNotNullByDefault;
+import org.briarproject.bramble.api.sync.GroupId;
+import org.briarproject.briar.R;
+import org.briarproject.briar.android.activity.BriarActivity;
+import org.briarproject.briar.android.fragment.BaseFragment.BaseFragmentListener;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+import javax.annotation.Nullable;
+
+@MethodsNotNullByDefault
+@ParametersNotNullByDefault
+public abstract class ContactSelectorActivity
+		extends BriarActivity
+		implements BaseFragmentListener, ContactSelectorListener {
+
+	final static String CONTACTS = "contacts";
+
+	// Subclasses may initialise the group ID in different places
+	protected GroupId groupId;
+	protected Collection<ContactId> contacts;
+
+	@Override
+	public void onCreate(@Nullable Bundle bundle) {
+		super.onCreate(bundle);
+
+		setContentView(getLayout());
+
+		if (Build.VERSION.SDK_INT >= 21) {
+			getWindow().setExitTransition(new Fade());
+		}
+
+		if (bundle != null) {
+			// restore group ID if it was saved
+			byte[] groupBytes = bundle.getByteArray(GROUP_ID);
+			if (groupBytes != null) groupId = new GroupId(groupBytes);
+			// restore selected contacts if a selection was saved
+			ArrayList<Integer> intContacts =
+					bundle.getIntegerArrayList(CONTACTS);
+			if (intContacts != null) {
+				contacts = getContactsFromIntegers(intContacts);
+			}
+		}
+	}
+
+	@LayoutRes
+	protected int getLayout() {
+		return R.layout.activity_fragment_container;
+	}
+
+	@Override
+	public void onSaveInstanceState(Bundle outState) {
+		super.onSaveInstanceState(outState);
+		if (groupId != null) {
+			// save the group ID here regardless of how subclasses initialize it
+			outState.putByteArray(GROUP_ID, groupId.getBytes());
+		}
+		if (contacts != null) {
+			outState.putIntegerArrayList(CONTACTS,
+					getContactsFromIds(contacts));
+		}
+	}
+
+	@CallSuper
+	@UiThread
+	@Override
+	public void contactsSelected(Collection<ContactId> contacts) {
+		this.contacts = contacts;
+	}
+
+	static ArrayList<Integer> getContactsFromIds(
+			Collection<ContactId> contacts) {
+		// transform ContactIds to Integers so they can be added to a bundle
+		ArrayList<Integer> intContacts = new ArrayList<>(contacts.size());
+		for (ContactId contactId : contacts) {
+			intContacts.add(contactId.getInt());
+		}
+		return intContacts;
+	}
+
+	static Collection<ContactId> getContactsFromIntegers(
+			ArrayList<Integer> intContacts) {
+		// turn contact integers from a bundle back to ContactIds
+		List<ContactId> contacts = new ArrayList<>(intContacts.size());
+		for (Integer c : intContacts) {
+			contacts.add(new ContactId(c));
+		}
+		return contacts;
+	}
+
+	@Override
+	public void onFragmentCreated(String tag) {
+
+	}
+
+}

briar-android/src/main/java/org/briarproject/briar/android/contactselection/ContactSelectorAdapter.java

@@ -0,0 +1,28 @@
+package org.briarproject.briar.android.contactselection;
+
+import android.content.Context;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+
+import org.briarproject.bramble.api.nullsafety.NotNullByDefault;
+import org.briarproject.briar.R;
+
+@NotNullByDefault
+class ContactSelectorAdapter extends
+		BaseContactSelectorAdapter<SelectableContactItem, SelectableContactHolder> {
+
+	ContactSelectorAdapter(Context context,
+			OnContactClickListener<SelectableContactItem> listener) {
+		super(context, SelectableContactItem.class, listener);
+	}
+
+	@Override
+	public SelectableContactHolder onCreateViewHolder(ViewGroup viewGroup,
+			int i) {
+		View v = LayoutInflater.from(ctx).inflate(
+				R.layout.list_item_selectable_contact, viewGroup, false);
+		return new SelectableContactHolder(v);
+	}
+
+}

briar-android/src/main/java/org/briarproject/briar/android/contactselection/ContactSelectorController.java

@@ -0,0 +1,19 @@
+package org.briarproject.briar.android.contactselection;
+
+import org.briarproject.bramble.api.contact.ContactId;
+import org.briarproject.bramble.api.db.DbException;
+import org.briarproject.bramble.api.nullsafety.NotNullByDefault;
+import org.briarproject.bramble.api.sync.GroupId;
+import org.briarproject.briar.android.controller.DbController;
+import org.briarproject.briar.android.controller.handler.ResultExceptionHandler;
+
+import java.util.Collection;
+
+@NotNullByDefault
+public interface ContactSelectorController<I extends SelectableContactItem>
+		extends DbController {
+
+	void loadContacts(GroupId g, Collection<ContactId> selection,
+			ResultExceptionHandler<Collection<I>, DbException> handler);
+
+}

briar-android/src/main/java/org/briarproject/briar/android/contactselection/ContactSelectorControllerImpl.java

@@ -0,0 +1,72 @@
+package org.briarproject.briar.android.contactselection;
+
+import org.briarproject.bramble.api.contact.Contact;
+import org.briarproject.bramble.api.contact.ContactId;
+import org.briarproject.bramble.api.contact.ContactManager;
+import org.briarproject.bramble.api.db.DatabaseExecutor;
+import org.briarproject.bramble.api.db.DbException;
+import org.briarproject.bramble.api.lifecycle.LifecycleManager;
+import org.briarproject.bramble.api.nullsafety.NotNullByDefault;
+import org.briarproject.bramble.api.sync.GroupId;
+import org.briarproject.briar.android.controller.DbControllerImpl;
+import org.briarproject.briar.android.controller.handler.ResultExceptionHandler;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.concurrent.Executor;
+import java.util.logging.Logger;
+
+import javax.annotation.concurrent.Immutable;
+
+import static java.util.logging.Level.WARNING;
+
+@Immutable
+@NotNullByDefault
+public abstract class ContactSelectorControllerImpl
+		extends DbControllerImpl
+		implements ContactSelectorController<SelectableContactItem> {
+
+	private static final Logger LOG =
+			Logger.getLogger(ContactSelectorControllerImpl.class.getName());
+
+	private final ContactManager contactManager;
+
+	public ContactSelectorControllerImpl(@DatabaseExecutor Executor dbExecutor,
+			LifecycleManager lifecycleManager, ContactManager contactManager) {
+		super(dbExecutor, lifecycleManager);
+		this.contactManager = contactManager;
+	}
+
+	@Override
+	public void loadContacts(final GroupId g,
+			final Collection<ContactId> selection,
+			final ResultExceptionHandler<Collection<SelectableContactItem>, DbException> handler) {
+		runOnDbThread(new Runnable() {
+			@Override
+			public void run() {
+				try {
+					Collection<SelectableContactItem> contacts =
+							new ArrayList<>();
+					for (Contact c : contactManager.getActiveContacts()) {
+						// was this contact already selected?
+						boolean selected = selection.contains(c.getId());
+						// can this contact be selected?
+						boolean disabled = isDisabled(g, c);
+						contacts.add(new SelectableContactItem(c, selected,
+								disabled));
+					}
+					handler.onResult(contacts);
+				} catch (DbException e) {
+					if (LOG.isLoggable(WARNING))
+						LOG.log(WARNING, e.toString(), e);
+					handler.onException(e);
+				}
+			}
+		});
+	}
+
+	@DatabaseExecutor
+	protected abstract boolean isDisabled(GroupId g, Contact c)
+			throws DbException;
+
+}

briar-android/src/main/java/org/briarproject/briar/android/contactselection/ContactSelectorFragment.java

@@ -0,0 +1,64 @@
+package org.briarproject.briar.android.contactselection;
+
+import android.content.Context;
+import android.view.Menu;
+import android.view.MenuInflater;
+import android.view.MenuItem;
+
+import org.briarproject.bramble.api.nullsafety.MethodsNotNullByDefault;
+import org.briarproject.bramble.api.nullsafety.ParametersNotNullByDefault;
+import org.briarproject.briar.R;
+import org.briarproject.briar.android.contact.BaseContactListAdapter.OnContactClickListener;
+
+@MethodsNotNullByDefault
+@ParametersNotNullByDefault
+public abstract class ContactSelectorFragment extends
+		BaseContactSelectorFragment<SelectableContactItem, ContactSelectorAdapter>
+		implements OnContactClickListener<SelectableContactItem> {
+
+	public static final String TAG = ContactSelectorFragment.class.getName();
+
+	private Menu menu;
+
+	@Override
+	protected ContactSelectorAdapter getAdapter(Context context,
+			OnContactClickListener<SelectableContactItem> listener) {
+		return new ContactSelectorAdapter(context, listener);
+	}
+
+	@Override
+	public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
+		inflater.inflate(R.menu.contact_selection_actions, menu);
+		super.onCreateOptionsMenu(menu, inflater);
+		this.menu = menu;
+		// hide sharing action initially, if no contact is selected
+		onSelectionChanged();
+	}
+
+	@Override
+	public boolean onOptionsItemSelected(final MenuItem item) {
+		switch (item.getItemId()) {
+			case R.id.action_contacts_selected:
+				selectedContacts = adapter.getSelectedContactIds();
+				listener.contactsSelected(selectedContacts);
+				return true;
+			default:
+				return super.onOptionsItemSelected(item);
+		}
+	}
+
+	@Override
+	protected void onSelectionChanged() {
+		if (menu == null) return;
+		MenuItem item = menu.findItem(R.id.action_contacts_selected);
+		if (item == null) return;
+
+		selectedContacts = adapter.getSelectedContactIds();
+		if (selectedContacts.size() > 0) {
+			item.setVisible(true);
+		} else {
+			item.setVisible(false);
+		}
+	}
+
+}

briar-android/src/main/java/org/briarproject/briar/android/contactselection/ContactSelectorListener.java

@@ -0,0 +1,17 @@
+package org.briarproject.briar.android.contactselection;
+
+import android.support.annotation.UiThread;
+
+import org.briarproject.bramble.api.contact.ContactId;
+import org.briarproject.bramble.api.nullsafety.NotNullByDefault;
+import org.briarproject.briar.android.DestroyableContext;
+
+import java.util.Collection;
+
+@NotNullByDefault
+public interface ContactSelectorListener extends DestroyableContext {
+
+	@UiThread
+	void contactsSelected(Collection<ContactId> contacts);
+
+}

briar-android/src/main/java/org/briarproject/briar/android/contactselection/SelectableContactHolder.java

@@ -0,0 +1,35 @@
+package org.briarproject.briar.android.contactselection;
+
+import android.support.annotation.UiThread;
+import android.view.View;
+
+import org.briarproject.bramble.api.nullsafety.NotNullByDefault;
+import org.briarproject.briar.android.contact.BaseContactListAdapter.OnContactClickListener;
+
+import javax.annotation.Nullable;
+
+import static android.view.View.GONE;
+import static android.view.View.VISIBLE;
+
+@UiThread
+@NotNullByDefault
+class SelectableContactHolder
+		extends BaseSelectableContactHolder<SelectableContactItem> {
+
+	SelectableContactHolder(View v) {
+		super(v);
+	}
+
+	@Override
+	protected void bind(SelectableContactItem item, @Nullable
+			OnContactClickListener<SelectableContactItem> listener) {
+		super.bind(item, listener);
+
+		if (item.isDisabled()) {
+			info.setVisibility(VISIBLE);
+		} else {
+			info.setVisibility(GONE);
+		}
+	}
+
+}

briar-android/src/main/java/org/briarproject/briar/android/contactselection/SelectableContactItem.java

@@ -0,0 +1,34 @@
+package org.briarproject.briar.android.contactselection;
+
+import org.briarproject.bramble.api.contact.Contact;
+import org.briarproject.bramble.api.nullsafety.NotNullByDefault;
+import org.briarproject.briar.android.contact.ContactItem;
+
+import javax.annotation.concurrent.NotThreadSafe;
+
+@NotThreadSafe
+@NotNullByDefault
+public class SelectableContactItem extends ContactItem {
+
+	private boolean selected, disabled;
+
+	public SelectableContactItem(Contact contact, boolean selected,
+			boolean disabled) {
+		super(contact);
+		this.selected = selected;
+		this.disabled = disabled;
+	}
+
+	boolean isSelected() {
+		return selected;
+	}
+
+	void toggleSelected() {
+		selected = !selected;
+	}
+
+	public boolean isDisabled() {
+		return disabled;
+	}
+
+}

briar-android/src/main/java/org/briarproject/briar/android/controller/ActivityLifecycleController.java

@@ -0,0 +1,14 @@
+package org.briarproject.briar.android.controller;
+
+import android.app.Activity;
+
+public interface ActivityLifecycleController {
+
+	void onActivityCreate(Activity activity);
+
+	void onActivityStart();
+
+	void onActivityStop();
+
+	void onActivityDestroy();
+}

briar-android/src/main/java/org/briarproject/briar/android/controller/BriarController.java

@@ -0,0 +1,12 @@
+package org.briarproject.briar.android.controller;
+
+import org.briarproject.briar.android.controller.handler.ResultHandler;
+
+public interface BriarController extends ActivityLifecycleController {
+
+	void startAndBindService();
+
+	boolean hasEncryptionKey();
+
+	void signOut(ResultHandler<Void> eventHandler);
+}

briar-android/src/main/java/org/briarproject/briar/android/controller/BriarControllerImpl.java

@@ -0,0 +1,95 @@
+package org.briarproject.briar.android.controller;
+
+import android.app.Activity;
+import android.content.Intent;
+import android.os.IBinder;
+import android.support.annotation.CallSuper;
+
+import org.briarproject.bramble.api.db.DatabaseConfig;
+import org.briarproject.briar.android.BriarService;
+import org.briarproject.briar.android.BriarService.BriarServiceConnection;
+import org.briarproject.briar.android.controller.handler.ResultHandler;
+
+import java.util.logging.Logger;
+
+import javax.inject.Inject;
+
+public class BriarControllerImpl implements BriarController {
+
+	private static final Logger LOG =
+			Logger.getLogger(BriarControllerImpl.class.getName());
+
+	private final BriarServiceConnection serviceConnection;
+	private final DatabaseConfig databaseConfig;
+	private final Activity activity;
+
+	private boolean bound = false;
+
+	@Inject
+	BriarControllerImpl(BriarServiceConnection serviceConnection,
+			DatabaseConfig databaseConfig, Activity activity) {
+		this.serviceConnection = serviceConnection;
+		this.databaseConfig = databaseConfig;
+		this.activity = activity;
+	}
+
+	@Override
+	@CallSuper
+	public void onActivityCreate(Activity activity) {
+		if (databaseConfig.getEncryptionKey() != null) startAndBindService();
+	}
+
+	@Override
+	public void onActivityStart() {
+	}
+
+	@Override
+	public void onActivityStop() {
+	}
+
+	@Override
+	@CallSuper
+	public void onActivityDestroy() {
+		unbindService();
+	}
+
+	@Override
+	public void startAndBindService() {
+		activity.startService(new Intent(activity, BriarService.class));
+		bound = activity.bindService(new Intent(activity, BriarService.class),
+				serviceConnection, 0);
+	}
+
+	@Override
+	public boolean hasEncryptionKey() {
+		return databaseConfig.getEncryptionKey() != null;
+	}
+
+	@Override
+	public void signOut(final ResultHandler<Void> eventHandler) {
+		new Thread() {
+			@Override
+			public void run() {
+				try {
+					// Wait for the service to finish starting up
+					IBinder binder = serviceConnection.waitForBinder();
+					BriarService service =
+							((BriarService.BriarBinder) binder).getService();
+					service.waitForStartup();
+					// Shut down the service and wait for it to shut down
+					LOG.info("Shutting down service");
+					service.shutdown();
+					service.waitForShutdown();
+				} catch (InterruptedException e) {
+					LOG.warning("Interrupted while waiting for service");
+				}
+				eventHandler.onResult(null);
+			}
+		}.start();
+	}
+
+	private void unbindService() {
+		if (bound) activity.unbindService(serviceConnection);
+	}
+
+}

briar-android/src/main/java/org/briarproject/briar/android/controller/ConfigController.java

@@ -0,0 +1,20 @@
+package org.briarproject.briar.android.controller;
+
+import android.content.Context;
+
+import org.briarproject.bramble.api.nullsafety.NotNullByDefault;
+
+import javax.annotation.Nullable;
+
+@NotNullByDefault
+public interface ConfigController {
+
+	@Nullable
+	String getEncryptedDatabaseKey();
+
+	void storeEncryptedDatabaseKey(String hex);
+
+	void deleteAccount(Context ctx);
+
+	boolean accountExists();
+}

briar-android/src/main/java/org/briarproject/briar/android/controller/ConfigControllerImpl.java

@@ -0,0 +1,55 @@
+package org.briarproject.briar.android.controller;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+
+import org.briarproject.bramble.api.db.DatabaseConfig;
+import org.briarproject.bramble.api.nullsafety.NotNullByDefault;
+import org.briarproject.bramble.util.AndroidUtils;
+
+import javax.annotation.Nullable;
+import javax.inject.Inject;
+
+@NotNullByDefault
+public class ConfigControllerImpl implements ConfigController {
+
+	private static final String PREF_DB_KEY = "key";
+
+	private final SharedPreferences briarPrefs;
+	protected final DatabaseConfig databaseConfig;
+
+	@Inject
+	public ConfigControllerImpl(SharedPreferences briarPrefs,
+			DatabaseConfig databaseConfig) {
+		this.briarPrefs = briarPrefs;
+		this.databaseConfig = databaseConfig;
+
+	}
+
+	@Override
+	@Nullable
+	public String getEncryptedDatabaseKey() {
+		return briarPrefs.getString(PREF_DB_KEY, null);
+	}
+
+	@Override
+	public void storeEncryptedDatabaseKey(String hex) {
+		SharedPreferences.Editor editor = briarPrefs.edit();
+		editor.putString(PREF_DB_KEY, hex);
+		editor.apply();
+	}
+
+	@Override
+	public void deleteAccount(Context ctx) {
+		SharedPreferences.Editor editor = briarPrefs.edit();
+		editor.clear();
+		editor.apply();
+		AndroidUtils.deleteAppData(ctx);
+	}
+
+	@Override
+	public boolean accountExists() {
+		String hex = getEncryptedDatabaseKey();
+		return hex != null && databaseConfig.databaseExists();
+	}
+}

briar-android/src/main/java/org/briarproject/briar/android/controller/DbController.java

@@ -0,0 +1,9 @@
+package org.briarproject.briar.android.controller;
+
+import org.briarproject.bramble.api.nullsafety.NotNullByDefault;
+
+@NotNullByDefault
+public interface DbController {
+
+	void runOnDbThread(Runnable task);
+}

briar-android/src/main/java/org/briarproject/briar/android/controller/DbControllerImpl.java

@@ -0,0 +1,45 @@
+package org.briarproject.briar.android.controller;
+
+import org.briarproject.bramble.api.db.DatabaseExecutor;
+import org.briarproject.bramble.api.lifecycle.LifecycleManager;
+import org.briarproject.bramble.api.nullsafety.NotNullByDefault;
+
+import java.util.concurrent.Executor;
+import java.util.logging.Logger;
+
+import javax.annotation.concurrent.Immutable;
+import javax.inject.Inject;
+
+@Immutable
+@NotNullByDefault
+public class DbControllerImpl implements DbController {
+
+	private static final Logger LOG =
+			Logger.getLogger(DbControllerImpl.class.getName());
+
+	private final Executor dbExecutor;
+	private final LifecycleManager lifecycleManager;
+
+	@Inject
+	public DbControllerImpl(@DatabaseExecutor Executor dbExecutor,
+			LifecycleManager lifecycleManager) {
+		this.dbExecutor = dbExecutor;
+		this.lifecycleManager = lifecycleManager;
+	}
+
+	@Override
+	public void runOnDbThread(final Runnable task) {
+		dbExecutor.execute(new Runnable() {
+			@Override
+			public void run() {
+				try {
+					lifecycleManager.waitForDatabase();
+					task.run();
+				} catch (InterruptedException e) {
+					LOG.warning("Interrupted while waiting for database");
+					Thread.currentThread().interrupt();
+				}
+			}
+		});
+	}
+}

briar-android/src/main/java/org/briarproject/briar/android/controller/handler/ExceptionHandler.java

@@ -0,0 +1,7 @@
+package org.briarproject.briar.android.controller.handler;
+
+public interface ExceptionHandler<E extends Exception> {
+
+	void onException(E exception);
+
+}

briar-android/src/main/java/org/briarproject/briar/android/controller/handler/ResultExceptionHandler.java

@@ -0,0 +1,8 @@
+package org.briarproject.briar.android.controller.handler;
+
+public interface ResultExceptionHandler<R, E extends Exception>
+		extends ExceptionHandler<E> {
+
+	void onResult(R result);
+
+}

briar-android/src/main/java/org/briarproject/briar/android/controller/handler/ResultHandler.java

@@ -0,0 +1,6 @@
+package org.briarproject.briar.android.controller.handler;
+
+public interface ResultHandler<R> {
+
+	void onResult(R result);
+}

briar-android/src/main/java/org/briarproject/briar/android/controller/handler/UiExceptionHandler.java

@@ -0,0 +1,34 @@
+package org.briarproject.briar.android.controller.handler;
+
+import android.support.annotation.UiThread;
+
+import org.briarproject.bramble.api.nullsafety.NotNullByDefault;
+import org.briarproject.briar.android.DestroyableContext;
+
+import javax.annotation.concurrent.Immutable;
+
+@Immutable
+@NotNullByDefault
+public abstract class UiExceptionHandler<E extends Exception>
+		implements ExceptionHandler<E> {
+
+	protected final DestroyableContext listener;
+
+	protected UiExceptionHandler(DestroyableContext listener) {
+		this.listener = listener;
+	}
+
+	@Override
+	public void onException(final E exception) {
+		listener.runOnUiThreadUnlessDestroyed(new Runnable() {
+			@Override
+			public void run() {
+				onExceptionUi(exception);
+			}
+		});
+	}
+
+	@UiThread
+	public abstract void onExceptionUi(E exception);
+
+}

briar-android/src/main/java/org/briarproject/briar/android/controller/handler/UiResultExceptionHandler.java

@@ -0,0 +1,32 @@
+package org.briarproject.briar.android.controller.handler;
+
+import android.support.annotation.UiThread;
+
+import org.briarproject.bramble.api.nullsafety.NotNullByDefault;
+import org.briarproject.briar.android.DestroyableContext;
+
+import javax.annotation.concurrent.Immutable;
+
+@Immutable
+@NotNullByDefault
+public abstract class UiResultExceptionHandler<R, E extends Exception>
+		extends UiExceptionHandler<E> implements ResultExceptionHandler<R, E> {
+
+	protected UiResultExceptionHandler(DestroyableContext listener) {
+		super(listener);
+	}
+
+	@Override
+	public void onResult(final R result) {
+		listener.runOnUiThreadUnlessDestroyed(new Runnable() {
+			@Override
+			public void run() {
+				onResultUi(result);
+			}
+		});
+	}
+
+	@UiThread
+	public abstract void onResultUi(R result);
+
+}

briar-android/src/main/java/org/briarproject/briar/android/controller/handler/UiResultHandler.java

@@ -0,0 +1,27 @@
+package org.briarproject.briar.android.controller.handler;
+
+import android.support.annotation.UiThread;
+
+import org.briarproject.briar.android.DestroyableContext;
+
+public abstract class UiResultHandler<R> implements ResultHandler<R> {
+
+	private final DestroyableContext listener;
+
+	protected UiResultHandler(DestroyableContext listener) {
+		this.listener = listener;
+	}
+
+	@Override
+	public void onResult(final R result) {
+		listener.runOnUiThreadUnlessDestroyed(new Runnable() {
+			@Override
+			public void run() {
+				onResultUi(result);
+			}
+		});
+	}
+
+	@UiThread
+	public abstract void onResultUi(R result);
+}

briar-android/src/main/java/org/briarproject/briar/android/forum/CreateForumActivity.java

@@ -0,0 +1,165 @@
+package org.briarproject.briar.android.forum;
+
+import android.content.Intent;
+import android.os.Bundle;
+import android.text.Editable;
+import android.text.TextWatcher;
+import android.view.KeyEvent;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.widget.Button;
+import android.widget.EditText;
+import android.widget.ProgressBar;
+import android.widget.TextView;
+import android.widget.TextView.OnEditorActionListener;
+import android.widget.Toast;
+
+import org.briarproject.bramble.api.db.DbException;
+import org.briarproject.bramble.api.nullsafety.MethodsNotNullByDefault;
+import org.briarproject.bramble.api.nullsafety.ParametersNotNullByDefault;
+import org.briarproject.bramble.util.StringUtils;
+import org.briarproject.briar.R;
+import org.briarproject.briar.android.activity.ActivityComponent;
+import org.briarproject.briar.android.activity.BriarActivity;
+import org.briarproject.briar.api.forum.Forum;
+import org.briarproject.briar.api.forum.ForumManager;
+
+import java.util.logging.Logger;
+
+import javax.annotation.Nullable;
+import javax.inject.Inject;
+
+import static android.view.View.GONE;
+import static android.view.View.VISIBLE;
+import static android.widget.Toast.LENGTH_LONG;
+import static java.util.logging.Level.INFO;
+import static java.util.logging.Level.WARNING;
+import static org.briarproject.briar.api.forum.ForumConstants.MAX_FORUM_NAME_LENGTH;
+
+@MethodsNotNullByDefault
+@ParametersNotNullByDefault
+public class CreateForumActivity extends BriarActivity
+		implements OnEditorActionListener, OnClickListener {
+
+	private static final Logger LOG =
+			Logger.getLogger(CreateForumActivity.class.getName());
+
+	private EditText nameEntry;
+	private Button createForumButton;
+	private ProgressBar progress;
+	private TextView feedback;
+
+	// Fields that are accessed from background threads must be volatile
+	@Inject
+	protected volatile ForumManager forumManager;
+
+	@Override
+	public void onCreate(@Nullable Bundle state) {
+		super.onCreate(state);
+
+		setContentView(R.layout.activity_create_forum);
+
+		nameEntry = (EditText) findViewById(R.id.createForumNameEntry);
+		TextWatcher nameEntryWatcher = new TextWatcher() {
+
+			@Override
+			public void afterTextChanged(Editable s) {
+			}
+
+			@Override
+			public void beforeTextChanged(CharSequence s, int start, int count,
+					int after) {
+			}
+
+			@Override
+			public void onTextChanged(CharSequence text, int start,
+					int lengthBefore, int lengthAfter) {
+				enableOrDisableCreateButton();
+			}
+		};
+		nameEntry.setOnEditorActionListener(this);
+		nameEntry.addTextChangedListener(nameEntryWatcher);
+
+		feedback = (TextView) findViewById(R.id.createForumFeedback);
+
+		createForumButton = (Button) findViewById(R.id.createForumButton);
+		createForumButton.setOnClickListener(this);
+
+		progress = (ProgressBar) findViewById(R.id.createForumProgressBar);
+
+	}
+
+	@Override
+	public void injectActivity(ActivityComponent component) {
+		component.inject(this);
+	}
+
+	private void enableOrDisableCreateButton() {
+		if (progress == null) return; // Not created yet
+		createForumButton.setEnabled(validateName());
+	}
+
+	@Override
+	public boolean onEditorAction(TextView textView, int actionId, KeyEvent e) {
+		hideSoftKeyboard(textView);
+		return true;
+	}
+
+	private boolean validateName() {
+		String name = nameEntry.getText().toString();
+		int length = StringUtils.toUtf8(name).length;
+		if (length > MAX_FORUM_NAME_LENGTH) {
+			feedback.setText(R.string.name_too_long);
+			return false;
+		}
+		feedback.setText("");
+		return length > 0;
+	}
+
+	@Override
+	public void onClick(View view) {
+		if (view == createForumButton) {
+			hideSoftKeyboard(view);
+			if (!validateName()) return;
+			createForumButton.setVisibility(GONE);
+			progress.setVisibility(VISIBLE);
+			storeForum(nameEntry.getText().toString());
+		}
+	}
+
+	private void storeForum(final String name) {
+		runOnDbThread(new Runnable() {
+			@Override
+			public void run() {
+				try {
+					long now = System.currentTimeMillis();
+					Forum f = forumManager.addForum(name);
+					long duration = System.currentTimeMillis() - now;
+					if (LOG.isLoggable(INFO))
+						LOG.info("Storing forum took " + duration + " ms");
+					displayForum(f);
+				} catch (DbException e) {
+					if (LOG.isLoggable(WARNING))
+						LOG.log(WARNING, e.toString(), e);
+					finishOnUiThread();
+				}
+			}
+		});
+	}
+
+	private void displayForum(final Forum f) {
+		runOnUiThreadUnlessDestroyed(new Runnable() {
+			@Override
+			public void run() {
+				Intent i = new Intent(CreateForumActivity.this,
+						ForumActivity.class);
+				i.putExtra(GROUP_ID, f.getId().getBytes());
+				i.putExtra(GROUP_NAME, f.getName());
+				startActivity(i);
+				Toast.makeText(CreateForumActivity.this,
+						R.string.forum_created_toast, LENGTH_LONG).show();
+				finish();
+			}
+		});
+	}
+}

briar-android/src/main/java/org/briarproject/briar/android/forum/ForumActivity.java

@@ -0,0 +1,186 @@
+package org.briarproject.briar.android.forum;
+
+import android.content.DialogInterface;
+import android.content.DialogInterface.OnClickListener;
+import android.content.Intent;
+import android.os.Bundle;
+import android.support.annotation.LayoutRes;
+import android.support.annotation.StringRes;
+import android.support.v4.app.ActivityCompat;
+import android.support.v4.app.ActivityOptionsCompat;
+import android.support.v7.app.AlertDialog;
+import android.support.v7.widget.LinearLayoutManager;
+import android.view.Menu;
+import android.view.MenuInflater;
+import android.view.MenuItem;
+import android.widget.Toast;
+
+import org.briarproject.bramble.api.db.DbException;
+import org.briarproject.bramble.api.nullsafety.MethodsNotNullByDefault;
+import org.briarproject.bramble.api.nullsafety.ParametersNotNullByDefault;
+import org.briarproject.briar.R;
+import org.briarproject.briar.android.activity.ActivityComponent;
+import org.briarproject.briar.android.controller.handler.UiResultExceptionHandler;
+import org.briarproject.briar.android.sharing.ForumSharingStatusActivity;
+import org.briarproject.briar.android.sharing.ShareForumActivity;
+import org.briarproject.briar.android.threaded.ThreadItemAdapter;
+import org.briarproject.briar.android.threaded.ThreadListActivity;
+import org.briarproject.briar.android.threaded.ThreadListController;
+import org.briarproject.briar.api.forum.Forum;
+import org.briarproject.briar.api.forum.ForumPostHeader;
+
+import javax.annotation.Nullable;
+import javax.inject.Inject;
+
+import static android.content.Intent.FLAG_ACTIVITY_CLEAR_TOP;
+import static android.content.Intent.FLAG_ACTIVITY_SINGLE_TOP;
+import static android.support.v4.app.ActivityOptionsCompat.makeCustomAnimation;
+import static android.widget.Toast.LENGTH_SHORT;
+import static org.briarproject.briar.api.forum.ForumConstants.MAX_FORUM_POST_BODY_LENGTH;
+
+@MethodsNotNullByDefault
+@ParametersNotNullByDefault
+public class ForumActivity extends
+		ThreadListActivity<Forum, ThreadItemAdapter<ForumItem>, ForumItem, ForumPostHeader> {
+
+	private static final int REQUEST_FORUM_SHARED = 3;
+
+	@Inject
+	ForumController forumController;
+
+	@Override
+	public void injectActivity(ActivityComponent component) {
+		component.inject(this);
+	}
+
+	@Override
+	protected ThreadListController<Forum, ForumItem, ForumPostHeader> getController() {
+		return forumController;
+	}
+
+	@Override
+	public void onCreate(@Nullable Bundle state) {
+		super.onCreate(state);
+
+		Intent i = getIntent();
+		String groupName = i.getStringExtra(GROUP_NAME);
+		if (groupName != null) setTitle(groupName);
+		else loadNamedGroup();
+	}
+
+	@Override
+	protected void onNamedGroupLoaded(Forum forum) {
+		setTitle(forum.getName());
+	}
+
+	@Override
+	@LayoutRes
+	protected int getLayout() {
+		return R.layout.activity_forum;
+	}
+
+	@Override
+	protected ThreadItemAdapter<ForumItem> createAdapter(
+			LinearLayoutManager layoutManager) {
+		return new ThreadItemAdapter<>(this, layoutManager);
+	}
+
+	@Override
+	protected void onActivityResult(int request, int result, Intent data) {
+		super.onActivityResult(request, result, data);
+
+		if (request == REQUEST_FORUM_SHARED && result == RESULT_OK) {
+			displaySnackbarShort(R.string.forum_shared_snackbar);
+		}
+	}
+
+	@Override
+	public boolean onCreateOptionsMenu(Menu menu) {
+		// Inflate the menu items for use in the action bar
+		MenuInflater inflater = getMenuInflater();
+		inflater.inflate(R.menu.forum_actions, menu);
+
+		return super.onCreateOptionsMenu(menu);
+	}
+
+	@Override
+	public boolean onOptionsItemSelected(final MenuItem item) {
+		ActivityOptionsCompat options = makeCustomAnimation(this,
+				android.R.anim.slide_in_left, android.R.anim.slide_out_right);
+		// Handle presses on the action bar items
+		switch (item.getItemId()) {
+			case R.id.action_forum_compose_post:
+				showTextInput(null);
+				return true;
+			case R.id.action_forum_share:
+				Intent i2 = new Intent(this, ShareForumActivity.class);
+				i2.setFlags(FLAG_ACTIVITY_CLEAR_TOP | FLAG_ACTIVITY_SINGLE_TOP);
+				i2.putExtra(GROUP_ID, groupId.getBytes());
+				ActivityCompat.startActivityForResult(this, i2,
+						REQUEST_FORUM_SHARED, options.toBundle());
+				return true;
+			case R.id.action_forum_sharing_status:
+				Intent i3 = new Intent(this, ForumSharingStatusActivity.class);
+				i3.setFlags(FLAG_ACTIVITY_CLEAR_TOP | FLAG_ACTIVITY_SINGLE_TOP);
+				i3.putExtra(GROUP_ID, groupId.getBytes());
+				ActivityCompat.startActivity(this, i3, options.toBundle());
+				return true;
+			case R.id.action_forum_delete:
+				showUnsubscribeDialog();
+				return true;
+			default:
+				return super.onOptionsItemSelected(item);
+		}
+	}
+
+	@Override
+	protected int getMaxBodyLength() {
+		return MAX_FORUM_POST_BODY_LENGTH;
+	}
+
+	@Override
+	@StringRes
+	protected int getItemPostedString() {
+		return R.string.forum_new_entry_posted;
+	}
+
+	@Override
+	@StringRes
+	protected int getItemReceivedString() {
+		return R.string.forum_new_entry_received;
+	}
+
+	private void showUnsubscribeDialog() {
+		OnClickListener okListener = new OnClickListener() {
+			@Override
+			public void onClick(DialogInterface dialog, int which) {
+				deleteForum();
+			}
+		};
+		AlertDialog.Builder builder = new AlertDialog.Builder(this,
+				R.style.BriarDialogTheme);
+		builder.setTitle(getString(R.string.dialog_title_leave_forum));
+		builder.setMessage(getString(R.string.dialog_message_leave_forum));
+		builder.setNegativeButton(R.string.dialog_button_leave, okListener);
+		builder.setPositiveButton(R.string.cancel, null);
+		builder.show();
+	}
+
+	private void deleteForum() {
+		forumController.deleteNamedGroup(
+				new UiResultExceptionHandler<Void, DbException>(this) {
+					@Override
+					public void onResultUi(Void v) {
+						Toast.makeText(ForumActivity.this,
+								R.string.forum_left_toast, LENGTH_SHORT).show();
+					}
+
+					@Override
+					public void onExceptionUi(DbException exception) {
+						// TODO proper error handling
+						finish();
+					}
+				});
+	}
+
+}

briar-android/src/main/java/org/briarproject/briar/android/forum/ForumController.java

@@ -0,0 +1,12 @@
+package org.briarproject.briar.android.forum;
+
+import org.briarproject.bramble.api.nullsafety.NotNullByDefault;
+import org.briarproject.briar.android.threaded.ThreadListController;
+import org.briarproject.briar.api.forum.Forum;
+import org.briarproject.briar.api.forum.ForumPostHeader;
+
+@NotNullByDefault
+interface ForumController
+		extends ThreadListController<Forum, ForumItem, ForumPostHeader> {
+
+}

briar-android/src/main/java/org/briarproject/briar/android/forum/ForumControllerImpl.java

@@ -0,0 +1,156 @@
+package org.briarproject.briar.android.forum;
+
+import org.briarproject.bramble.api.crypto.CryptoExecutor;
+import org.briarproject.bramble.api.db.DatabaseExecutor;
+import org.briarproject.bramble.api.db.DbException;
+import org.briarproject.bramble.api.event.Event;
+import org.briarproject.bramble.api.event.EventBus;
+import org.briarproject.bramble.api.identity.IdentityManager;
+import org.briarproject.bramble.api.identity.LocalAuthor;
+import org.briarproject.bramble.api.lifecycle.LifecycleManager;
+import org.briarproject.bramble.api.nullsafety.NotNullByDefault;
+import org.briarproject.bramble.api.sync.MessageId;
+import org.briarproject.bramble.api.system.Clock;
+import org.briarproject.briar.android.controller.handler.ResultExceptionHandler;
+import org.briarproject.briar.android.threaded.ThreadListController.ThreadListListener;
+import org.briarproject.briar.android.threaded.ThreadListControllerImpl;
+import org.briarproject.briar.api.android.AndroidNotificationManager;
+import org.briarproject.briar.api.client.MessageTracker.GroupCount;
+import org.briarproject.briar.api.forum.Forum;
+import org.briarproject.briar.api.forum.ForumManager;
+import org.briarproject.briar.api.forum.ForumPost;
+import org.briarproject.briar.api.forum.ForumPostHeader;
+import org.briarproject.briar.api.forum.event.ForumPostReceivedEvent;
+
+import java.util.Collection;
+import java.util.concurrent.Executor;
+import java.util.logging.Logger;
+
+import javax.annotation.Nullable;
+import javax.inject.Inject;
+
+import static java.lang.Math.max;
+import static java.util.logging.Level.WARNING;
+
+@NotNullByDefault
+class ForumControllerImpl extends
+		ThreadListControllerImpl<Forum, ForumItem, ForumPostHeader, ForumPost, ThreadListListener<ForumPostHeader>>
+		implements ForumController {
+
+	private static final Logger LOG =
+			Logger.getLogger(ForumControllerImpl.class.getName());
+
+	private final ForumManager forumManager;
+
+	@Inject
+	ForumControllerImpl(@DatabaseExecutor Executor dbExecutor,
+			LifecycleManager lifecycleManager, IdentityManager identityManager,
+			@CryptoExecutor Executor cryptoExecutor,
+			ForumManager forumManager, EventBus eventBus,
+			Clock clock, AndroidNotificationManager notificationManager) {
+		super(dbExecutor, lifecycleManager, identityManager, cryptoExecutor,
+				eventBus, clock, notificationManager);
+		this.forumManager = forumManager;
+	}
+
+	@Override
+	public void onActivityStart() {
+		super.onActivityStart();
+		notificationManager.clearForumPostNotification(getGroupId());
+	}
+
+	@Override
+	public void eventOccurred(Event e) {
+		super.eventOccurred(e);
+
+		if (e instanceof ForumPostReceivedEvent) {
+			ForumPostReceivedEvent pe = (ForumPostReceivedEvent) e;
+			if (pe.getGroupId().equals(getGroupId())) {
+				LOG.info("Forum post received, adding...");
+				final ForumPostHeader fph = pe.getForumPostHeader();
+				listener.runOnUiThreadUnlessDestroyed(new Runnable() {
+					@Override
+					public void run() {
+						listener.onHeaderReceived(fph);
+					}
+				});
+			}
+		}
+	}
+
+	@Override
+	protected Forum loadNamedGroup() throws DbException {
+		return forumManager.getForum(getGroupId());
+	}
+
+	@Override
+	protected Collection<ForumPostHeader> loadHeaders() throws DbException {
+		return forumManager.getPostHeaders(getGroupId());
+	}
+
+	@Override
+	protected String loadMessageBody(ForumPostHeader h) throws DbException {
+		return forumManager.getPostBody(h.getId());
+	}
+
+	@Override
+	protected void markRead(MessageId id) throws DbException {
+		forumManager.setReadFlag(getGroupId(), id, true);
+	}
+
+	@Override
+	public void createAndStoreMessage(final String body,
+			@Nullable final ForumItem parentItem,
+			final ResultExceptionHandler<ForumItem, DbException> handler) {
+		runOnDbThread(new Runnable() {
+			@Override
+			public void run() {
+				try {
+					LocalAuthor author = identityManager.getLocalAuthor();
+					GroupCount count = forumManager.getGroupCount(getGroupId());
+					long timestamp = max(count.getLatestMsgTime() + 1,
+							clock.currentTimeMillis());
+					MessageId parentId = parentItem != null ?
+							parentItem.getId() : null;
+					createMessage(body, timestamp, parentId, author, handler);
+				} catch (DbException e) {
+					if (LOG.isLoggable(WARNING))
+						LOG.log(WARNING, e.toString(), e);
+					handler.onException(e);
+				}
+			}
+		});
+	}
+
+	private void createMessage(final String body, final long timestamp,
+			final @Nullable MessageId parentId, final LocalAuthor author,
+			final ResultExceptionHandler<ForumItem, DbException> handler) {
+		cryptoExecutor.execute(new Runnable() {
+			@Override
+			public void run() {
+				LOG.info("Creating forum post...");
+				ForumPost msg = forumManager
+						.createLocalPost(getGroupId(), body, timestamp,
+								parentId, author);
+				storePost(msg, body, handler);
+			}
+		});
+	}
+
+	@Override
+	protected ForumPostHeader addLocalMessage(ForumPost p)
+			throws DbException {
+		return forumManager.addLocalPost(p);
+	}
+
+	@Override
+	protected void deleteNamedGroup(Forum forum) throws DbException {
+		forumManager.removeForum(forum);
+	}
+
+	@Override
+	protected ForumItem buildItem(ForumPostHeader header, String body) {
+		return new ForumItem(header, body);
+	}
+
+}

briar-android/src/main/java/org/briarproject/briar/android/forum/ForumItem.java

@@ -0,0 +1,25 @@
+package org.briarproject.briar.android.forum;
+
+import org.briarproject.bramble.api.identity.Author;
+import org.briarproject.bramble.api.identity.Author.Status;
+import org.briarproject.bramble.api.sync.MessageId;
+import org.briarproject.briar.android.threaded.ThreadItem;
+import org.briarproject.briar.api.forum.ForumPostHeader;
+
+import javax.annotation.Nullable;
+import javax.annotation.concurrent.NotThreadSafe;
+
+@NotThreadSafe
+class ForumItem extends ThreadItem {
+
+	ForumItem(ForumPostHeader h, String body) {
+		super(h.getId(), h.getParentId(), body, h.getTimestamp(), h.getAuthor(),
+				h.getAuthorStatus(), h.isRead());
+	}
+
+	ForumItem(MessageId messageId, @Nullable MessageId parentId, String text,
+			long timestamp, Author author, Status status) {
+		super(messageId, parentId, text, timestamp, author, status, true);
+	}
+
+}

briar-android/src/main/java/org/briarproject/briar/android/forum/ForumListAdapter.java

@@ -0,0 +1,145 @@
+package org.briarproject.briar.android.forum;
+
+import android.content.Context;
+import android.content.Intent;
+import android.support.v4.content.ContextCompat;
+import android.support.v7.widget.RecyclerView;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.TextView;
+
+import org.briarproject.bramble.api.sync.GroupId;
+import org.briarproject.briar.R;
+import org.briarproject.briar.android.util.BriarAdapter;
+import org.briarproject.briar.android.util.UiUtils;
+import org.briarproject.briar.android.view.TextAvatarView;
+import org.briarproject.briar.api.forum.Forum;
+
+import static android.support.v7.util.SortedList.INVALID_POSITION;
+import static android.view.View.GONE;
+import static android.view.View.VISIBLE;
+import static org.briarproject.briar.android.activity.BriarActivity.GROUP_ID;
+import static org.briarproject.briar.android.activity.BriarActivity.GROUP_NAME;
+
+class ForumListAdapter
+		extends BriarAdapter<ForumListItem, ForumListAdapter.ForumViewHolder> {
+
+	ForumListAdapter(Context ctx) {
+		super(ctx, ForumListItem.class);
+	}
+
+	@Override
+	public ForumViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
+		View v = LayoutInflater.from(ctx).inflate(
+				R.layout.list_item_forum, parent, false);
+		return new ForumViewHolder(v);
+	}
+
+	@Override
+	public void onBindViewHolder(ForumViewHolder ui, int position) {
+		final ForumListItem item = getItemAt(position);
+		if (item == null) return;
+
+		// Avatar
+		ui.avatar.setText(item.getForum().getName().substring(0, 1));
+		ui.avatar.setBackgroundBytes(item.getForum().getId().getBytes());
+		ui.avatar.setUnreadCount(item.getUnreadCount());
+
+		// Forum Name
+		ui.name.setText(item.getForum().getName());
+
+		// Post Count
+		int postCount = item.getPostCount();
+		if (postCount > 0) {
+			ui.avatar.setProblem(false);
+			ui.postCount.setText(ctx.getResources()
+					.getQuantityString(R.plurals.posts, postCount,
+							postCount));
+			ui.postCount.setTextColor(
+					ContextCompat
+							.getColor(ctx, R.color.briar_text_secondary));
+		} else {
+			ui.avatar.setProblem(true);
+			ui.postCount.setText(ctx.getString(R.string.no_posts));
+			ui.postCount.setTextColor(
+					ContextCompat
+							.getColor(ctx, R.color.briar_text_tertiary));
+		}
+
+		// Date
+		if (item.isEmpty()) {
+			ui.date.setVisibility(GONE);
+		} else {
+			long timestamp = item.getTimestamp();
+			ui.date.setText(UiUtils.formatDate(ctx, timestamp));
+			ui.date.setVisibility(VISIBLE);
+		}
+
+		// Open Forum on Click
+		ui.layout.setOnClickListener(new View.OnClickListener() {
+			@Override
+			public void onClick(View v) {
+				Intent i = new Intent(ctx, ForumActivity.class);
+				Forum f = item.getForum();
+				i.putExtra(GROUP_ID, f.getId().getBytes());
+				i.putExtra(GROUP_NAME, f.getName());
+				ctx.startActivity(i);
+			}
+		});
+	}
+
+	@Override
+	public int compare(ForumListItem a, ForumListItem b) {
+		if (a == b) return 0;
+		// The forum with the newest message comes first
+		long aTime = a.getTimestamp(), bTime = b.getTimestamp();
+		if (aTime > bTime) return -1;
+		if (aTime < bTime) return 1;
+		// Break ties by forum name
+		String aName = a.getForum().getName();
+		String bName = b.getForum().getName();
+		return String.CASE_INSENSITIVE_ORDER.compare(aName, bName);
+	}
+
+	@Override
+	public boolean areContentsTheSame(ForumListItem a, ForumListItem b) {
+		return a.isEmpty() == b.isEmpty() &&
+				a.getTimestamp() == b.getTimestamp() &&
+				a.getUnreadCount() == b.getUnreadCount();
+	}
+
+	@Override
+	public boolean areItemsTheSame(ForumListItem a, ForumListItem b) {
+		return a.getForum().equals(b.getForum());
+	}
+
+	int findItemPosition(GroupId g) {
+		int count = getItemCount();
+		for (int i = 0; i < count; i++) {
+			ForumListItem item = getItemAt(i);
+			if (item != null && item.getForum().getGroup().getId().equals(g))
+				return i;
+		}
+		return INVALID_POSITION; // Not found
+	}
+
+	static class ForumViewHolder extends RecyclerView.ViewHolder {
+
+		private final ViewGroup layout;
+		private final TextAvatarView avatar;
+		private final TextView name;
+		private final TextView postCount;
+		private final TextView date;
+
+		private ForumViewHolder(View v) {
+			super(v);
+
+			layout = (ViewGroup) v;
+			avatar = (TextAvatarView) v.findViewById(R.id.avatarView);
+			name = (TextView) v.findViewById(R.id.forumNameView);
+			postCount = (TextView) v.findViewById(R.id.postCountView);
+			date = (TextView) v.findViewById(R.id.dateView);
+		}
+	}
+}

briar-android/src/main/java/org/briarproject/briar/android/forum/ForumListFragment.java

@@ -0,0 +1,298 @@
+package org.briarproject.briar.android.forum;
+
+import android.content.Intent;
+import android.os.Bundle;
+import android.support.design.widget.Snackbar;
+import android.support.v4.content.ContextCompat;
+import android.support.v7.widget.LinearLayoutManager;
+import android.view.LayoutInflater;
+import android.view.Menu;
+import android.view.MenuInflater;
+import android.view.MenuItem;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.view.ViewGroup;
+
+import org.briarproject.bramble.api.contact.event.ContactRemovedEvent;
+import org.briarproject.bramble.api.db.DbException;
+import org.briarproject.bramble.api.db.NoSuchGroupException;
+import org.briarproject.bramble.api.event.Event;
+import org.briarproject.bramble.api.nullsafety.MethodsNotNullByDefault;
+import org.briarproject.bramble.api.nullsafety.ParametersNotNullByDefault;
+import org.briarproject.bramble.api.sync.GroupId;
+import org.briarproject.bramble.api.sync.event.GroupAddedEvent;
+import org.briarproject.bramble.api.sync.event.GroupRemovedEvent;
+import org.briarproject.briar.R;
+import org.briarproject.briar.android.activity.ActivityComponent;
+import org.briarproject.briar.android.fragment.BaseEventFragment;
+import org.briarproject.briar.android.sharing.ForumInvitationActivity;
+import org.briarproject.briar.android.view.BriarRecyclerView;
+import org.briarproject.briar.api.android.AndroidNotificationManager;
+import org.briarproject.briar.api.client.MessageTracker.GroupCount;
+import org.briarproject.briar.api.forum.Forum;
+import org.briarproject.briar.api.forum.ForumManager;
+import org.briarproject.briar.api.forum.ForumPostHeader;
+import org.briarproject.briar.api.forum.ForumSharingManager;
+import org.briarproject.briar.api.forum.event.ForumInvitationRequestReceivedEvent;
+import org.briarproject.briar.api.forum.event.ForumPostReceivedEvent;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.logging.Logger;
+
+import javax.annotation.Nullable;
+import javax.inject.Inject;
+
+import static android.support.design.widget.Snackbar.LENGTH_INDEFINITE;
+import static java.util.logging.Level.INFO;
+import static java.util.logging.Level.WARNING;
+import static org.briarproject.briar.api.forum.ForumManager.CLIENT_ID;
+
+@MethodsNotNullByDefault
+@ParametersNotNullByDefault
+public class ForumListFragment extends BaseEventFragment implements
+		OnClickListener {
+
+	public final static String TAG = ForumListFragment.class.getName();
+	private final static Logger LOG = Logger.getLogger(TAG);
+
+	private BriarRecyclerView list;
+	private ForumListAdapter adapter;
+	private Snackbar snackbar;
+
+	@Inject
+	AndroidNotificationManager notificationManager;
+
+	// Fields that are accessed from background threads must be volatile
+	@Inject
+	volatile ForumManager forumManager;
+	@Inject
+	volatile ForumSharingManager forumSharingManager;
+
+	public static ForumListFragment newInstance() {
+
+		Bundle args = new Bundle();
+
+		ForumListFragment fragment = new ForumListFragment();
+		fragment.setArguments(args);
+		return fragment;
+	}
+
+	@Nullable
+	@Override
+	public View onCreateView(LayoutInflater inflater,
+			@Nullable ViewGroup container,
+			@Nullable Bundle savedInstanceState) {
+
+		View contentView =
+				inflater.inflate(R.layout.fragment_forum_list, container,
+						false);
+
+		adapter = new ForumListAdapter(getActivity());
+
+		list = (BriarRecyclerView) contentView.findViewById(R.id.forumList);
+		list.setLayoutManager(new LinearLayoutManager(getActivity()));
+		list.setAdapter(adapter);
+		list.setEmptyText(getString(R.string.no_forums));
+
+		snackbar = Snackbar.make(list, "", LENGTH_INDEFINITE);
+		snackbar.getView().setBackgroundResource(R.color.briar_primary);
+		snackbar.setAction(R.string.show, this);
+		snackbar.setActionTextColor(ContextCompat
+				.getColor(getContext(), R.color.briar_button_positive));
+
+		return contentView;
+	}
+
+	@Override
+	public String getUniqueTag() {
+		return TAG;
+	}
+
+	@Override
+	public void injectFragment(ActivityComponent component) {
+		component.inject(this);
+	}
+
+	@Override
+	public void onStart() {
+		super.onStart();
+		notificationManager.blockAllForumPostNotifications();
+		notificationManager.clearAllForumPostNotifications();
+		loadForums();
+		loadAvailableForums();
+		list.startPeriodicUpdate();
+	}
+
+	@Override
+	public void onStop() {
+		super.onStop();
+		notificationManager.unblockAllForumPostNotifications();
+		adapter.clear();
+		list.showProgressBar();
+		list.stopPeriodicUpdate();
+	}
+
+	@Override
+	public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
+		inflater.inflate(R.menu.forum_list_actions, menu);
+		super.onCreateOptionsMenu(menu, inflater);
+	}
+
+	@Override
+	public boolean onOptionsItemSelected(final MenuItem item) {
+		// Handle presses on the action bar items
+		switch (item.getItemId()) {
+			case R.id.action_create_forum:
+				Intent intent =
+						new Intent(getContext(), CreateForumActivity.class);
+				startActivity(intent);
+				return true;
+			default:
+				return super.onOptionsItemSelected(item);
+		}
+	}
+
+	private void loadForums() {
+		final int revision = adapter.getRevision();
+		listener.runOnDbThread(new Runnable() {
+			@Override
+			public void run() {
+				try {
+					long now = System.currentTimeMillis();
+					Collection<ForumListItem> forums = new ArrayList<>();
+					for (Forum f : forumManager.getForums()) {
+						try {
+							GroupCount count =
+									forumManager.getGroupCount(f.getId());
+							forums.add(new ForumListItem(f, count));
+						} catch (NoSuchGroupException e) {
+							// Continue
+						}
+					}
+					long duration = System.currentTimeMillis() - now;
+					if (LOG.isLoggable(INFO))
+						LOG.info("Full load took " + duration + " ms");
+					displayForums(revision, forums);
+				} catch (DbException e) {
+					if (LOG.isLoggable(WARNING))
+						LOG.log(WARNING, e.toString(), e);
+				}
+			}
+		});
+	}
+
+	private void displayForums(final int revision,
+			final Collection<ForumListItem> forums) {
+		runOnUiThreadUnlessDestroyed(new Runnable() {
+			@Override
+			public void run() {
+				if (revision == adapter.getRevision()) {
+					adapter.incrementRevision();
+					if (forums.isEmpty()) list.showData();
+					else adapter.addAll(forums);
+				} else {
+					LOG.info("Concurrent update, reloading");
+					loadForums();
+				}
+			}
+		});
+	}
+
+	private void loadAvailableForums() {
+		listener.runOnDbThread(new Runnable() {
+			@Override
+			public void run() {
+				try {
+					long now = System.currentTimeMillis();
+					int available =
+							forumSharingManager.getInvitations().size();
+					long duration = System.currentTimeMillis() - now;
+					if (LOG.isLoggable(INFO))
+						LOG.info("Loading available took " + duration + " ms");
+					displayAvailableForums(available);
+				} catch (DbException e) {
+					if (LOG.isLoggable(WARNING))
+						LOG.log(WARNING, e.toString(), e);
+				}
+			}
+		});
+	}
+
+	private void displayAvailableForums(final int availableCount) {
+		runOnUiThreadUnlessDestroyed(new Runnable() {
+			@Override
+			public void run() {
+				if (availableCount == 0) {
+					snackbar.dismiss();
+				} else {
+					snackbar.setText(getResources().getQuantityString(
+							R.plurals.forums_shared, availableCount,
+							availableCount));
+					if (!snackbar.isShownOrQueued()) snackbar.show();
+				}
+			}
+		});
+	}
+
+	@Override
+	public void eventOccurred(Event e) {
+		if (e instanceof ContactRemovedEvent) {
+			LOG.info("Contact removed, reloading available forums");
+			loadAvailableForums();
+		} else if (e instanceof GroupAddedEvent) {
+			GroupAddedEvent g = (GroupAddedEvent) e;
+			if (g.getGroup().getClientId().equals(CLIENT_ID)) {
+				LOG.info("Forum added, reloading forums");
+				loadForums();
+			}
+		} else if (e instanceof GroupRemovedEvent) {
+			GroupRemovedEvent g = (GroupRemovedEvent) e;
+			if (g.getGroup().getClientId().equals(CLIENT_ID)) {
+				LOG.info("Forum removed, removing from list");
+				removeForum(g.getGroup().getId());
+			}
+		} else if (e instanceof ForumPostReceivedEvent) {
+			ForumPostReceivedEvent f = (ForumPostReceivedEvent) e;
+			LOG.info("Forum post added, updating item");
+			updateItem(f.getGroupId(), f.getForumPostHeader());
+		} else if (e instanceof ForumInvitationRequestReceivedEvent) {
+			LOG.info("Forum invitation received, reloading available forums");
+			loadAvailableForums();
+		}
+	}
+
+	private void updateItem(final GroupId g, final ForumPostHeader m) {
+		runOnUiThreadUnlessDestroyed(new Runnable() {
+			@Override
+			public void run() {
+				adapter.incrementRevision();
+				int position = adapter.findItemPosition(g);
+				ForumListItem item = adapter.getItemAt(position);
+				if (item != null) {
+					item.addHeader(m);
+					adapter.updateItemAt(position, item);
+				}
+			}
+		});
+	}
+
+	private void removeForum(final GroupId g) {
+		runOnUiThreadUnlessDestroyed(new Runnable() {
+			@Override
+			public void run() {
+				adapter.incrementRevision();
+				int position = adapter.findItemPosition(g);
+				ForumListItem item = adapter.getItemAt(position);
+				if (item != null) adapter.remove(item);
+			}
+		});
+	}
+
+	@Override
+	public void onClick(View view) {
+		// snackbar click
+		Intent i = new Intent(getContext(), ForumInvitationActivity.class);
+		startActivity(i);
+	}
+}

briar-android/src/main/java/org/briarproject/briar/android/forum/ForumListItem.java

@@ -0,0 +1,46 @@
+package org.briarproject.briar.android.forum;
+
+import org.briarproject.briar.api.client.MessageTracker.GroupCount;
+import org.briarproject.briar.api.forum.Forum;
+import org.briarproject.briar.api.forum.ForumPostHeader;
+
+// This class is NOT thread-safe
+class ForumListItem {
+
+	private final Forum forum;
+	private int postCount, unread;
+	private long timestamp;
+
+	ForumListItem(Forum forum, GroupCount count) {
+		this.forum = forum;
+		this.postCount = count.getMsgCount();
+		this.unread = count.getUnreadCount();
+		this.timestamp = count.getLatestMsgTime();
+	}
+
+	void addHeader(ForumPostHeader h) {
+		postCount++;
+		if (!h.isRead()) unread++;
+		if (h.getTimestamp() > timestamp) timestamp = h.getTimestamp();
+	}
+
+	Forum getForum() {
+		return forum;
+	}
+
+	boolean isEmpty() {
+		return postCount == 0;
+	}
+
+	int getPostCount() {
+		return postCount;
+	}
+
+	long getTimestamp() {
+		return timestamp;
+	}
+
+	int getUnreadCount() {
+		return unread;
+	}
+}

briar-android/src/main/java/org/briarproject/briar/android/forum/ForumModule.java

@@ -0,0 +1,20 @@
+package org.briarproject.briar.android.forum;
+
+import org.briarproject.briar.android.activity.ActivityScope;
+import org.briarproject.briar.android.activity.BaseActivity;
+
+import dagger.Module;
+import dagger.Provides;
+
+@Module
+public class ForumModule {
+
+	@ActivityScope
+	@Provides
+	ForumController provideForumController(BaseActivity activity,
+			ForumControllerImpl forumController) {
+		activity.addLifecycleController(forumController);
+		return forumController;
+	}
+
+}

briar-android/src/main/java/org/briarproject/briar/android/fragment/BaseEventFragment.java

@@ -0,0 +1,25 @@
+package org.briarproject.briar.android.fragment;
+
+import org.briarproject.bramble.api.event.EventBus;
+import org.briarproject.bramble.api.event.EventListener;
+
+import javax.inject.Inject;
+
+public abstract class BaseEventFragment extends BaseFragment implements
+		EventListener {
+
+	@Inject
+	protected volatile EventBus eventBus;
+
+	@Override
+	public void onStart() {
+		super.onStart();
+		eventBus.addListener(this);
+	}
+
+	@Override
+	public void onStop() {
+		super.onStop();
+		eventBus.removeListener(this);
+	}
+}