Refactor attachment creation to use injection.

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

@@ -30,6 +30,7 @@ import org.briarproject.bramble.api.system.LocationUtils;
 import org.briarproject.bramble.plugin.tor.CircumventionProvider;
 import org.briarproject.briar.BriarCoreEagerSingletons;
 import org.briarproject.briar.BriarCoreModule;
+import org.briarproject.briar.android.attachment.AttachmentModule;
 import org.briarproject.briar.android.conversation.glide.BriarModelLoader;
 import org.briarproject.briar.android.login.SignInReminderReceiver;
 import org.briarproject.briar.android.reporting.BriarReportSender;
@@ -68,7 +69,8 @@ import dagger.Component;
 		BriarCoreModule.class,
 		BrambleAndroidModule.class,
 		BriarAccountModule.class,
-		AppModule.class
+		AppModule.class,
+		AttachmentModule.class
 })
 public interface AndroidComponent
 		extends BrambleCoreEagerSingletons, BrambleAndroidEagerSingletons,

briar-android/src/main/java/org/briarproject/briar/android/attachment/AttachmentCreator.java

@@ -1,85 +1,24 @@
 package org.briarproject.briar.android.attachment;
 
-
-import android.app.Application;
 import android.arch.lifecycle.LiveData;
-import android.arch.lifecycle.MutableLiveData;
 import android.net.Uri;
-import android.support.annotation.Nullable;
 import android.support.annotation.UiThread;
 
-import org.briarproject.bramble.api.db.DbException;
 import org.briarproject.bramble.api.lifecycle.IoExecutor;
 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.messaging.Attachment;
 import org.briarproject.briar.api.messaging.AttachmentHeader;
-import org.briarproject.briar.api.messaging.FileTooBigException;
-import org.briarproject.briar.api.messaging.MessagingManager;
-import org.jsoup.UnsupportedMimeTypeException;
 
-import java.io.IOException;
-import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
-import java.util.concurrent.CopyOnWriteArrayList;
-import java.util.concurrent.Executor;
-import java.util.logging.Logger;
-
-import static java.util.logging.Level.WARNING;
-import static java.util.logging.Logger.getLogger;
-import static org.briarproject.bramble.util.LogUtils.logException;
-import static org.briarproject.briar.android.util.UiUtils.observeForeverOnce;
-import static org.briarproject.briar.api.messaging.MessagingConstants.MAX_IMAGE_SIZE;
 
 @NotNullByDefault
-public class AttachmentCreator {
-
-	private static Logger LOG = getLogger(AttachmentCreator.class.getName());
-
-	private final Application app;
-	@IoExecutor
-	private final Executor ioExecutor;
-	private final MessagingManager messagingManager;
-	private final AttachmentRetriever retriever;
-
-	private final CopyOnWriteArrayList<Uri> uris = new CopyOnWriteArrayList<>();
-	private final CopyOnWriteArrayList<AttachmentItemResult> itemResults =
-			new CopyOnWriteArrayList<>();
-
-	@Nullable
-	private AttachmentCreationTask task;
-
-	@Nullable
-	private volatile MutableLiveData<AttachmentResult> result;
-
-	public AttachmentCreator(Application app, @IoExecutor Executor ioExecutor,
-			MessagingManager messagingManager, AttachmentRetriever retriever) {
-		this.app = app;
-		this.ioExecutor = ioExecutor;
-		this.messagingManager = messagingManager;
-		this.retriever = retriever;
-	}
+public interface AttachmentCreator {
 
 	@UiThread
-	public LiveData<AttachmentResult> storeAttachments(
-			LiveData<GroupId> groupId, Collection<Uri> newUris) {
-		if (task != null || result != null || !uris.isEmpty())
-			throw new IllegalStateException();
-		uris.addAll(newUris);
-		observeForeverOnce(groupId, id -> {
-			if (id == null) throw new IllegalStateException();
-			boolean needsSize = uris.size() == 1;
-			task = new AttachmentCreationTask(messagingManager,
-					app.getContentResolver(), this, id, uris, needsSize);
-			ioExecutor.execute(() -> task.storeAttachments());
-		});
-		MutableLiveData<AttachmentResult> result = new MutableLiveData<>();
-		this.result = result;
-		return result;
-	}
+	LiveData<AttachmentResult> storeAttachments(LiveData<GroupId> groupId,
+			Collection<Uri> newUris);
 
 	/**
 	 * This should be only called after configuration changes.
@@ -87,72 +26,10 @@ public class AttachmentCreator {
 	 * They are already being created and returned by the existing LiveData.
 	 */
 	@UiThread
-	public LiveData<AttachmentResult> getLiveAttachments() {
-		MutableLiveData<AttachmentResult> result = this.result;
-		if (task == null || result == null || uris.isEmpty())
-			throw new IllegalStateException();
-		// A task is already running. It will update the result LiveData.
-		// So nothing more to do here.
-		return result;
-	}
-
-	@IoExecutor
-	void onAttachmentHeaderReceived(Uri uri, AttachmentHeader h,
-			boolean needsSize) {
-		// get and cache AttachmentItem for ImagePreview
-		try {
-			Attachment a = retriever.getMessageAttachment(h);
-			AttachmentItem item = retriever.getAttachmentItem(a, needsSize);
-			if (item.hasError()) throw new IOException();
-			AttachmentItemResult itemResult =
-					new AttachmentItemResult(uri, item);
-			itemResults.add(itemResult);
-			MutableLiveData<AttachmentResult> result = this.result;
-			if (result != null) result.postValue(getResult(false));
-		} catch (IOException | DbException e) {
-			logException(LOG, WARNING, e);
-			onAttachmentError(uri, e);
-		}
-	}
-
-	@IoExecutor
-	void onAttachmentError(Uri uri, Throwable t) {
-		// get error message
-		String errorMsg;
-		if (t instanceof UnsupportedMimeTypeException) {
-			String mimeType = ((UnsupportedMimeTypeException) t).getMimeType();
-			errorMsg = app.getString(
-					R.string.image_attach_error_invalid_mime_type, mimeType);
-		} else if (t instanceof FileTooBigException) {
-			int mb = MAX_IMAGE_SIZE / 1024 / 1024;
-			errorMsg = app.getString(R.string.image_attach_error_too_big, mb);
-		} else {
-			errorMsg = null; // generic error
-		}
-		AttachmentItemResult itemResult =
-				new AttachmentItemResult(uri, errorMsg);
-		itemResults.add(itemResult);
-		MutableLiveData<AttachmentResult> result = this.result;
-		if (result != null) result.postValue(getResult(false));
-		// expect to receive a cancel from the UI
-	}
-
-	@IoExecutor
-	void onAttachmentCreationFinished() {
-		MutableLiveData<AttachmentResult> result = this.result;
-		if (result != null) result.postValue(getResult(true));
-	}
+	LiveData<AttachmentResult> getLiveAttachments();
 
 	@UiThread
-	public List<AttachmentHeader> getAttachmentHeadersForSending() {
-		List<AttachmentHeader> headers = new ArrayList<>(itemResults.size());
-		for (AttachmentItemResult itemResult : itemResults) {
-			// check if we are trying to send attachment items with errors
-			if (itemResult.getItem() == null) throw new IllegalStateException();
-			headers.add(itemResult.getItem().getHeader());
-		}
-		return headers;
-	}
+	List<AttachmentHeader> getAttachmentHeadersForSending();
 
 	/**
 	 * Marks the attachments as sent and adds the items to the cache for display
@@ -160,70 +37,24 @@ public class AttachmentCreator {
 	 * @param id The MessageId of the sent message.
 	 */
 	@UiThread
-	public void onAttachmentsSent(MessageId id) {
-		List<AttachmentItem> items = new ArrayList<>(itemResults.size());
-		for (AttachmentItemResult itemResult : itemResults) {
-			// check if we are trying to send attachment items with errors
-			if (itemResult.getItem() == null) throw new IllegalStateException();
-			items.add(itemResult.getItem());
-		}
-		retriever.cachePut(id, items);
-		resetState();
-	}
+	void onAttachmentsSent(MessageId id);
 
 	/**
 	 * Needs to be called when created attachments will not be sent anymore.
 	 */
 	@UiThread
-	public void cancel() {
-		if (task == null) throw new AssertionError();
-		task.cancel();
-		deleteUnsentAttachments();
-		resetState();
-	}
+	void cancel();
 
 	@UiThread
-	private void resetState() {
-		task = null;
-		uris.clear();
-		itemResults.clear();
-		MutableLiveData<AttachmentResult> result = this.result;
-		if (result != null) {
-			result.setValue(null);
-			this.result = null;
-		}
-	}
+	void deleteUnsentAttachments();
 
-	@UiThread
-	public void deleteUnsentAttachments() {
-		// Make a copy for the IoExecutor as we clear the itemResults soon
-		List<AttachmentHeader> headers = new ArrayList<>(itemResults.size());
-		for (AttachmentItemResult itemResult : itemResults) {
-			// check if we are trying to send attachment items with errors
-			if (itemResult.getItem() != null)
-				headers.add(itemResult.getItem().getHeader());
-		}
-		ioExecutor.execute(() -> {
-			for (AttachmentHeader header : headers) {
-				try {
-					messagingManager.removeAttachment(header);
-				} catch (DbException e) {
-					logException(LOG, WARNING, e);
-				}
-			}
-		});
-	}
+	@IoExecutor
+	void onAttachmentHeaderReceived(Uri uri, AttachmentHeader h,
+			boolean needsSize);
 
-	private AttachmentResult getResult(boolean finished) {
-		// Make a copy of the list,
-		// because our copy will continue to change in the background.
-		// (As it's a CopyOnWriteArrayList,
-		//  the code that receives the result can safely do simple things
-		//  like iterating over the list,
-		//  but anything that involves calling more than one list method
-		//  is still unsafe.)
-		Collection<AttachmentItemResult> items = new ArrayList<>(itemResults);
-		return new AttachmentResult(items, finished);
-	}
+	@IoExecutor
+	void onAttachmentError(Uri uri, Throwable t);
 
-}
+	@IoExecutor
+	void onAttachmentCreationFinished();
+}

briar-android/src/main/java/org/briarproject/briar/android/attachment/AttachmentCreatorImpl.java

@@ -0,0 +1,229 @@
+package org.briarproject.briar.android.attachment;
+
+
+import android.app.Application;
+import android.arch.lifecycle.LiveData;
+import android.arch.lifecycle.MutableLiveData;
+import android.net.Uri;
+import android.support.annotation.Nullable;
+import android.support.annotation.UiThread;
+
+import org.briarproject.bramble.api.db.DbException;
+import org.briarproject.bramble.api.lifecycle.IoExecutor;
+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.messaging.Attachment;
+import org.briarproject.briar.api.messaging.AttachmentHeader;
+import org.briarproject.briar.api.messaging.FileTooBigException;
+import org.briarproject.briar.api.messaging.MessagingManager;
+import org.jsoup.UnsupportedMimeTypeException;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.Executor;
+import java.util.logging.Logger;
+
+import javax.inject.Inject;
+
+import static java.util.logging.Level.WARNING;
+import static java.util.logging.Logger.getLogger;
+import static org.briarproject.bramble.util.LogUtils.logException;
+import static org.briarproject.briar.android.util.UiUtils.observeForeverOnce;
+import static org.briarproject.briar.api.messaging.MessagingConstants.MAX_IMAGE_SIZE;
+
+@NotNullByDefault
+class AttachmentCreatorImpl implements AttachmentCreator {
+
+	private static Logger LOG =
+			getLogger(AttachmentCreatorImpl.class.getName());
+
+	private final Application app;
+	@IoExecutor
+	private final Executor ioExecutor;
+	private final MessagingManager messagingManager;
+	private final AttachmentRetriever retriever;
+
+	private final CopyOnWriteArrayList<Uri> uris = new CopyOnWriteArrayList<>();
+	private final CopyOnWriteArrayList<AttachmentItemResult> itemResults =
+			new CopyOnWriteArrayList<>();
+
+	@Nullable
+	private AttachmentCreationTask task;
+
+	@Nullable
+	private volatile MutableLiveData<AttachmentResult> result;
+
+	@Inject
+	AttachmentCreatorImpl(Application app, @IoExecutor Executor ioExecutor,
+			MessagingManager messagingManager, AttachmentRetriever retriever) {
+		this.app = app;
+		this.ioExecutor = ioExecutor;
+		this.messagingManager = messagingManager;
+		this.retriever = retriever;
+	}
+
+	@Override
+	@UiThread
+	public LiveData<AttachmentResult> storeAttachments(
+			LiveData<GroupId> groupId, Collection<Uri> newUris) {
+		if (task != null || result != null || !uris.isEmpty())
+			throw new IllegalStateException();
+		uris.addAll(newUris);
+		observeForeverOnce(groupId, id -> {
+			if (id == null) throw new IllegalStateException();
+			boolean needsSize = uris.size() == 1;
+			task = new AttachmentCreationTask(messagingManager,
+					app.getContentResolver(), this, id, uris, needsSize);
+			ioExecutor.execute(() -> task.storeAttachments());
+		});
+		MutableLiveData<AttachmentResult> result = new MutableLiveData<>();
+		this.result = result;
+		return result;
+	}
+
+	@Override
+	@UiThread
+	public LiveData<AttachmentResult> getLiveAttachments() {
+		MutableLiveData<AttachmentResult> result = this.result;
+		if (task == null || result == null || uris.isEmpty())
+			throw new IllegalStateException();
+		// A task is already running. It will update the result LiveData.
+		// So nothing more to do here.
+		return result;
+	}
+
+	@Override
+	@IoExecutor
+	public void onAttachmentHeaderReceived(Uri uri, AttachmentHeader h,
+			boolean needsSize) {
+		// get and cache AttachmentItem for ImagePreview
+		try {
+			Attachment a = retriever.getMessageAttachment(h);
+			AttachmentItem item = retriever.getAttachmentItem(a, needsSize);
+			if (item.hasError()) throw new IOException();
+			AttachmentItemResult itemResult =
+					new AttachmentItemResult(uri, item);
+			itemResults.add(itemResult);
+			MutableLiveData<AttachmentResult> result = this.result;
+			if (result != null) result.postValue(getResult(false));
+		} catch (IOException | DbException e) {
+			logException(LOG, WARNING, e);
+			onAttachmentError(uri, e);
+		}
+	}
+
+	@Override
+	@IoExecutor
+	public void onAttachmentError(Uri uri, Throwable t) {
+		// get error message
+		String errorMsg;
+		if (t instanceof UnsupportedMimeTypeException) {
+			String mimeType = ((UnsupportedMimeTypeException) t).getMimeType();
+			errorMsg = app.getString(
+					R.string.image_attach_error_invalid_mime_type, mimeType);
+		} else if (t instanceof FileTooBigException) {
+			int mb = MAX_IMAGE_SIZE / 1024 / 1024;
+			errorMsg = app.getString(R.string.image_attach_error_too_big, mb);
+		} else {
+			errorMsg = null; // generic error
+		}
+		AttachmentItemResult itemResult =
+				new AttachmentItemResult(uri, errorMsg);
+		itemResults.add(itemResult);
+		MutableLiveData<AttachmentResult> result = this.result;
+		if (result != null) result.postValue(getResult(false));
+		// expect to receive a cancel from the UI
+	}
+
+	@Override
+	@IoExecutor
+	public void onAttachmentCreationFinished() {
+		MutableLiveData<AttachmentResult> result = this.result;
+		if (result != null) result.postValue(getResult(true));
+	}
+
+	@Override
+	@UiThread
+	public List<AttachmentHeader> getAttachmentHeadersForSending() {
+		List<AttachmentHeader> headers = new ArrayList<>(itemResults.size());
+		for (AttachmentItemResult itemResult : itemResults) {
+			// check if we are trying to send attachment items with errors
+			if (itemResult.getItem() == null) throw new IllegalStateException();
+			headers.add(itemResult.getItem().getHeader());
+		}
+		return headers;
+	}
+
+	@Override
+	@UiThread
+	public void onAttachmentsSent(MessageId id) {
+		List<AttachmentItem> items = new ArrayList<>(itemResults.size());
+		for (AttachmentItemResult itemResult : itemResults) {
+			// check if we are trying to send attachment items with errors
+			if (itemResult.getItem() == null) throw new IllegalStateException();
+			items.add(itemResult.getItem());
+		}
+		retriever.cachePut(id, items);
+		resetState();
+	}
+
+	@Override
+	@UiThread
+	public void cancel() {
+		if (task == null) throw new AssertionError();
+		task.cancel();
+		deleteUnsentAttachments();
+		resetState();
+	}
+
+	@UiThread
+	private void resetState() {
+		task = null;
+		uris.clear();
+		itemResults.clear();
+		MutableLiveData<AttachmentResult> result = this.result;
+		if (result != null) {
+			result.setValue(null);
+			this.result = null;
+		}
+	}
+
+	@Override
+	@UiThread
+	public void deleteUnsentAttachments() {
+		// Make a copy for the IoExecutor as we clear the itemResults soon
+		List<AttachmentHeader> headers = new ArrayList<>(itemResults.size());
+		for (AttachmentItemResult itemResult : itemResults) {
+			// check if we are trying to send attachment items with errors
+			if (itemResult.getItem() != null)
+				headers.add(itemResult.getItem().getHeader());
+		}
+		ioExecutor.execute(() -> {
+			for (AttachmentHeader header : headers) {
+				try {
+					messagingManager.removeAttachment(header);
+				} catch (DbException e) {
+					logException(LOG, WARNING, e);
+				}
+			}
+		});
+	}
+
+	private AttachmentResult getResult(boolean finished) {
+		// Make a copy of the list,
+		// because our copy will continue to change in the background.
+		// (As it's a CopyOnWriteArrayList,
+		//  the code that receives the result can safely do simple things
+		//  like iterating over the list,
+		//  but anything that involves calling more than one list method
+		//  is still unsafe.)
+		Collection<AttachmentItemResult> items = new ArrayList<>(itemResults);
+		return new AttachmentResult(items, finished);
+	}
+
+}

briar-android/src/main/java/org/briarproject/briar/android/attachment/AttachmentDimensions.java

@@ -10,7 +10,7 @@ import javax.annotation.concurrent.Immutable;
 
 @Immutable
 @NotNullByDefault
-public class AttachmentDimensions {
+class AttachmentDimensions {
 
 	final int defaultSize;
 	final int minWidth, maxWidth;
@@ -26,7 +26,7 @@ public class AttachmentDimensions {
 		this.maxHeight = maxHeight;
 	}
 
-	public static AttachmentDimensions getAttachmentDimensions(Resources res) {
+	static AttachmentDimensions getAttachmentDimensions(Resources res) {
 		int defaultSize =
 				res.getDimensionPixelSize(R.dimen.message_bubble_image_default);
 		int minWidth = res.getDimensionPixelSize(

briar-android/src/main/java/org/briarproject/briar/android/attachment/AttachmentManager.java

@@ -4,12 +4,14 @@ import android.arch.lifecycle.LiveData;
 import android.net.Uri;
 import android.support.annotation.UiThread;
 
+import org.briarproject.bramble.api.nullsafety.NotNullByDefault;
 import org.briarproject.briar.api.messaging.AttachmentHeader;
 
 import java.util.Collection;
 import java.util.List;
 
 @UiThread
+@NotNullByDefault
 public interface AttachmentManager {
 
 	LiveData<AttachmentResult> storeAttachments(Collection<Uri> uri,

briar-android/src/main/java/org/briarproject/briar/android/attachment/AttachmentModule.java

@@ -0,0 +1,43 @@
+package org.briarproject.briar.android.attachment;
+
+import android.app.Application;
+
+import javax.inject.Singleton;
+
+import dagger.Module;
+import dagger.Provides;
+
+import static org.briarproject.briar.android.attachment.AttachmentDimensions.getAttachmentDimensions;
+
+@Module
+public class AttachmentModule {
+
+	@Provides
+	ImageHelper provideImageHelper(ImageHelperImpl imageHelper) {
+		return imageHelper;
+	}
+
+	@Provides
+	ImageSizeCalculator provideImageSizeCalculator(ImageHelper imageHelper) {
+		return new ImageSizeCalculator(imageHelper);
+	}
+
+	@Provides
+	AttachmentDimensions provideAttachmentDimensions(Application app) {
+		return getAttachmentDimensions(app.getResources());
+	}
+
+	@Provides
+	@Singleton
+	AttachmentRetriever provideAttachmentRetriever(
+			AttachmentRetrieverImpl attachmentRetriever) {
+		return attachmentRetriever;
+	}
+
+	@Provides
+	@Singleton
+	AttachmentCreator provideAttachmentCreator(
+			AttachmentCreatorImpl attachmentCreator) {
+		return attachmentCreator;
+	}
+}

briar-android/src/main/java/org/briarproject/briar/android/attachment/AttachmentRetriever.java

@@ -1,241 +1,29 @@
 package org.briarproject.briar.android.attachment;
 
-import android.graphics.BitmapFactory;
-import android.graphics.BitmapFactory.Options;
 import android.support.annotation.Nullable;
-import android.support.annotation.VisibleForTesting;
-import android.support.media.ExifInterface;
-import android.webkit.MimeTypeMap;
-
-import com.bumptech.glide.util.MarkEnforcingInputStream;
 
 import org.briarproject.bramble.api.db.DbException;
 import org.briarproject.bramble.api.nullsafety.NotNullByDefault;
 import org.briarproject.bramble.api.sync.MessageId;
-import org.briarproject.briar.android.attachment.ImageHelper.DecodeResult;
 import org.briarproject.briar.api.messaging.Attachment;
 import org.briarproject.briar.api.messaging.AttachmentHeader;
-import org.briarproject.briar.api.messaging.MessagingManager;
 
-import java.io.BufferedInputStream;
-import java.io.IOException;
 import java.io.InputStream;
 import java.util.List;
-import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.logging.Logger;
-
-import static android.support.media.ExifInterface.ORIENTATION_ROTATE_270;
-import static android.support.media.ExifInterface.ORIENTATION_ROTATE_90;
-import static android.support.media.ExifInterface.ORIENTATION_TRANSPOSE;
-import static android.support.media.ExifInterface.ORIENTATION_TRANSVERSE;
-import static android.support.media.ExifInterface.TAG_IMAGE_LENGTH;
-import static android.support.media.ExifInterface.TAG_IMAGE_WIDTH;
-import static android.support.media.ExifInterface.TAG_ORIENTATION;
-import static java.util.logging.Level.WARNING;
-import static java.util.logging.Logger.getLogger;
-import static org.briarproject.bramble.util.IoUtils.tryToClose;
-import static org.briarproject.bramble.util.LogUtils.logException;
 
 @NotNullByDefault
-public class AttachmentRetriever {
+public interface AttachmentRetriever {
 
-	private static final Logger LOG =
-			getLogger(AttachmentRetriever.class.getName());
-	private static final int READ_LIMIT = 1024 * 8192;
-
-	private final MessagingManager messagingManager;
-	private final ImageHelper imageHelper;
-	private final int defaultSize;
-	private final int minWidth, maxWidth;
-	private final int minHeight, maxHeight;
-
-	private final Map<MessageId, List<AttachmentItem>> attachmentCache =
-			new ConcurrentHashMap<>();
-
-	@VisibleForTesting
-	AttachmentRetriever(MessagingManager messagingManager,
-			AttachmentDimensions dimensions, ImageHelper imageHelper) {
-		this.messagingManager = messagingManager;
-		this.imageHelper = imageHelper;
-		defaultSize = dimensions.defaultSize;
-		minWidth = dimensions.minWidth;
-		maxWidth = dimensions.maxWidth;
-		minHeight = dimensions.minHeight;
-		maxHeight = dimensions.maxHeight;
-	}
-
-	public AttachmentRetriever(MessagingManager messagingManager,
-			AttachmentDimensions dimensions) {
-		this(messagingManager, dimensions, new ImageHelper() {
-			@Override
-			public DecodeResult decodeStream(InputStream is) {
-				Options options = new Options();
-				options.inJustDecodeBounds = true;
-				BitmapFactory.decodeStream(is, null, options);
-				String mimeType = options.outMimeType;
-				if (mimeType == null) mimeType = "";
-				return new DecodeResult(options.outWidth, options.outHeight,
-						mimeType);
-			}
-
-			@Nullable
-			@Override
-			public String getExtensionFromMimeType(String mimeType) {
-				MimeTypeMap mimeTypeMap = MimeTypeMap.getSingleton();
-				return mimeTypeMap.getExtensionFromMimeType(mimeType);
-			}
-		});
-	}
-
-	public void cachePut(MessageId messageId,
-			List<AttachmentItem> attachments) {
-		attachmentCache.put(messageId, attachments);
-	}
+	void cachePut(MessageId messageId, List<AttachmentItem> attachments);
 
 	@Nullable
-	public List<AttachmentItem> cacheGet(MessageId messageId) {
-		return attachmentCache.get(messageId);
-	}
+	List<AttachmentItem> cacheGet(MessageId messageId);
 
-	public Attachment getMessageAttachment(AttachmentHeader h)
-			throws DbException {
-		return messagingManager.getAttachment(h);
-	}
+	Attachment getMessageAttachment(AttachmentHeader h) throws DbException;
 
 	/**
 	 * Creates an {@link AttachmentItem} from the {@link Attachment}'s
 	 * {@link InputStream} which will be closed when this method returns.
 	 */
-	public AttachmentItem getAttachmentItem(Attachment a, boolean needsSize) {
-		AttachmentHeader h = a.getHeader();
-		if (!needsSize) {
-			String extension =
-					imageHelper.getExtensionFromMimeType(h.getContentType());
-			boolean hasError = false;
-			if (extension == null) {
-				extension = "";
-				hasError = true;
-			}
-			return new AttachmentItem(h, 0, 0, extension, 0, 0, hasError);
-		}
-
-		Size size = new Size();
-		InputStream is = new MarkEnforcingInputStream(
-				new BufferedInputStream(a.getStream()));
-		is.mark(READ_LIMIT);
-		try {
-			// use exif to get size
-			if (h.getContentType().equals("image/jpeg")) {
-				size = getSizeFromExif(is);
-			}
-		} catch (IOException e) {
-			logException(LOG, WARNING, e);
-		}
-		try {
-			// use BitmapFactory to get size
-			if (size.error) {
-				is.reset();
-				// need to mark again to re-add read limit
-				is.mark(READ_LIMIT);
-				size = getSizeFromBitmap(is);
-			}
-		} catch (IOException e) {
-			logException(LOG, WARNING, e);
-		} finally {
-			tryToClose(is, LOG, WARNING);
-		}
-
-		// calculate thumbnail size
-		Size thumbnailSize = new Size(defaultSize, defaultSize, size.mimeType);
-		if (!size.error) {
-			thumbnailSize =
-					getThumbnailSize(size.width, size.height, size.mimeType);
-		}
-		// get file extension
-		String extension = imageHelper.getExtensionFromMimeType(size.mimeType);
-		boolean hasError = extension == null || size.error;
-		if (!h.getContentType().equals(size.mimeType)) {
-			if (LOG.isLoggable(WARNING)) {
-				LOG.warning("Header has different mime type (" +
-						h.getContentType() + ") than image (" + size.mimeType +
-						").");
-			}
-			hasError = true;
-		}
-		if (extension == null) extension = "";
-		return new AttachmentItem(h, size.width, size.height, extension,
-				thumbnailSize.width, thumbnailSize.height, hasError);
-	}
-
-	/**
-	 * Gets the size of a JPEG {@link InputStream} if EXIF info is available.
-	 */
-	private Size getSizeFromExif(InputStream is) throws IOException {
-		ExifInterface exif = new ExifInterface(is);
-		// these can return 0 independent of default value
-		int width = exif.getAttributeInt(TAG_IMAGE_WIDTH, 0);
-		int height = exif.getAttributeInt(TAG_IMAGE_LENGTH, 0);
-		if (width == 0 || height == 0) return new Size();
-		int orientation = exif.getAttributeInt(TAG_ORIENTATION, 0);
-		if (orientation == ORIENTATION_ROTATE_90 ||
-				orientation == ORIENTATION_ROTATE_270 ||
-				orientation == ORIENTATION_TRANSVERSE ||
-				orientation == ORIENTATION_TRANSPOSE) {
-			//noinspection SuspiciousNameCombination
-			return new Size(height, width, "image/jpeg");
-		}
-		return new Size(width, height, "image/jpeg");
-	}
-
-	/**
-	 * Gets the size of any image {@link InputStream}.
-	 */
-	private Size getSizeFromBitmap(InputStream is) {
-		DecodeResult result = imageHelper.decodeStream(is);
-		if (result.width < 1 || result.height < 1) return new Size();
-		return new Size(result.width, result.height, result.mimeType);
-	}
-
-	private Size getThumbnailSize(int width, int height, String mimeType) {
-		float widthPercentage = maxWidth / (float) width;
-		float heightPercentage = maxHeight / (float) height;
-		float scaleFactor = Math.min(widthPercentage, heightPercentage);
-		if (scaleFactor > 1) scaleFactor = 1f;
-		int thumbnailWidth = (int) (width * scaleFactor);
-		int thumbnailHeight = (int) (height * scaleFactor);
-		if (thumbnailWidth < minWidth || thumbnailHeight < minHeight) {
-			widthPercentage = minWidth / (float) width;
-			heightPercentage = minHeight / (float) height;
-			scaleFactor = Math.max(widthPercentage, heightPercentage);
-			thumbnailWidth = (int) (width * scaleFactor);
-			thumbnailHeight = (int) (height * scaleFactor);
-			if (thumbnailWidth > maxWidth) thumbnailWidth = maxWidth;
-			if (thumbnailHeight > maxHeight) thumbnailHeight = maxHeight;
-		}
-		return new Size(thumbnailWidth, thumbnailHeight, mimeType);
-	}
-
-	private static class Size {
-
-		private final int width;
-		private final int height;
-		private final String mimeType;
-		private final boolean error;
-
-		private Size(int width, int height, String mimeType) {
-			this.width = width;
-			this.height = height;
-			this.mimeType = mimeType;
-			this.error = false;
-		}
-
-		private Size() {
-			this.width = 0;
-			this.height = 0;
-			this.mimeType = "";
-			this.error = true;
-		}
-	}
-
+	AttachmentItem getAttachmentItem(Attachment a, boolean needsSize);
 }

briar-android/src/main/java/org/briarproject/briar/android/attachment/AttachmentRetrieverImpl.java

@@ -0,0 +1,128 @@
+package org.briarproject.briar.android.attachment;
+
+import android.support.annotation.Nullable;
+
+import org.briarproject.bramble.api.db.DbException;
+import org.briarproject.bramble.api.nullsafety.NotNullByDefault;
+import org.briarproject.bramble.api.sync.MessageId;
+import org.briarproject.briar.api.messaging.Attachment;
+import org.briarproject.briar.api.messaging.AttachmentHeader;
+import org.briarproject.briar.api.messaging.MessagingManager;
+
+import java.io.BufferedInputStream;
+import java.io.InputStream;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.logging.Logger;
+
+import javax.inject.Inject;
+
+import static java.util.logging.Level.WARNING;
+import static java.util.logging.Logger.getLogger;
+
+@NotNullByDefault
+class AttachmentRetrieverImpl implements AttachmentRetriever {
+
+	private static final Logger LOG =
+			getLogger(AttachmentRetrieverImpl.class.getName());
+
+	private final MessagingManager messagingManager;
+	private final ImageHelper imageHelper;
+	private final ImageSizeCalculator imageSizeCalculator;
+	private final int defaultSize;
+	private final int minWidth, maxWidth;
+	private final int minHeight, maxHeight;
+
+	private final Map<MessageId, List<AttachmentItem>> attachmentCache =
+			new ConcurrentHashMap<>();
+
+	@Inject
+	AttachmentRetrieverImpl(MessagingManager messagingManager,
+			AttachmentDimensions dimensions, ImageHelper imageHelper) {
+		this.messagingManager = messagingManager;
+		this.imageHelper = imageHelper;
+		imageSizeCalculator = new ImageSizeCalculator(imageHelper);
+		defaultSize = dimensions.defaultSize;
+		minWidth = dimensions.minWidth;
+		maxWidth = dimensions.maxWidth;
+		minHeight = dimensions.minHeight;
+		maxHeight = dimensions.maxHeight;
+	}
+
+	@Override
+	public void cachePut(MessageId messageId,
+			List<AttachmentItem> attachments) {
+		attachmentCache.put(messageId, attachments);
+	}
+
+	@Override
+	@Nullable
+	public List<AttachmentItem> cacheGet(MessageId messageId) {
+		return attachmentCache.get(messageId);
+	}
+
+	@Override
+	public Attachment getMessageAttachment(AttachmentHeader h)
+			throws DbException {
+		return messagingManager.getAttachment(h);
+	}
+
+	@Override
+	public AttachmentItem getAttachmentItem(Attachment a, boolean needsSize) {
+		AttachmentHeader h = a.getHeader();
+		if (!needsSize) {
+			String extension =
+					imageHelper.getExtensionFromMimeType(h.getContentType());
+			boolean hasError = false;
+			if (extension == null) {
+				extension = "";
+				hasError = true;
+			}
+			return new AttachmentItem(h, 0, 0, extension, 0, 0, hasError);
+		}
+
+		InputStream is = new BufferedInputStream(a.getStream());
+		Size size = imageSizeCalculator.getSize(is, h.getContentType());
+
+		// calculate thumbnail size
+		Size thumbnailSize = new Size(defaultSize, defaultSize, size.mimeType);
+		if (!size.error) {
+			thumbnailSize =
+					getThumbnailSize(size.width, size.height, size.mimeType);
+		}
+		// get file extension
+		String extension = imageHelper.getExtensionFromMimeType(size.mimeType);
+		boolean hasError = extension == null || size.error;
+		if (!h.getContentType().equals(size.mimeType)) {
+			if (LOG.isLoggable(WARNING)) {
+				LOG.warning("Header has different mime type (" +
+						h.getContentType() + ") than image (" + size.mimeType +
+						").");
+			}
+			hasError = true;
+		}
+		if (extension == null) extension = "";
+		return new AttachmentItem(h, size.width, size.height, extension,
+				thumbnailSize.width, thumbnailSize.height, hasError);
+	}
+
+	private Size getThumbnailSize(int width, int height, String mimeType) {
+		float widthPercentage = maxWidth / (float) width;
+		float heightPercentage = maxHeight / (float) height;
+		float scaleFactor = Math.min(widthPercentage, heightPercentage);
+		if (scaleFactor > 1) scaleFactor = 1f;
+		int thumbnailWidth = (int) (width * scaleFactor);
+		int thumbnailHeight = (int) (height * scaleFactor);
+		if (thumbnailWidth < minWidth || thumbnailHeight < minHeight) {
+			widthPercentage = minWidth / (float) width;
+			heightPercentage = minHeight / (float) height;
+			scaleFactor = Math.max(widthPercentage, heightPercentage);
+			thumbnailWidth = (int) (width * scaleFactor);
+			thumbnailHeight = (int) (height * scaleFactor);
+			if (thumbnailWidth > maxWidth) thumbnailWidth = maxWidth;
+			if (thumbnailHeight > maxHeight) thumbnailHeight = maxHeight;
+		}
+		return new Size(thumbnailWidth, thumbnailHeight, mimeType);
+	}
+}

briar-android/src/main/java/org/briarproject/briar/android/attachment/ImageHelper.java

@@ -7,7 +7,7 @@ import org.briarproject.bramble.api.nullsafety.NotNullByDefault;
 import java.io.InputStream;
 
 @NotNullByDefault
-interface ImageHelper {
+public interface ImageHelper {
 
 	DecodeResult decodeStream(InputStream is);
 

briar-android/src/main/java/org/briarproject/briar/android/attachment/ImageHelperImpl.java

@@ -0,0 +1,39 @@
+package org.briarproject.briar.android.attachment;
+
+import android.graphics.BitmapFactory;
+import android.support.annotation.Nullable;
+import android.webkit.MimeTypeMap;
+
+import org.briarproject.bramble.api.nullsafety.NotNullByDefault;
+
+import java.io.InputStream;
+
+import javax.annotation.concurrent.Immutable;
+import javax.inject.Inject;
+
+@Immutable
+@NotNullByDefault
+class ImageHelperImpl implements ImageHelper {
+
+	@Inject
+	ImageHelperImpl() {
+	}
+
+	@Override
+	public DecodeResult decodeStream(InputStream is) {
+		BitmapFactory.Options options = new BitmapFactory.Options();
+		options.inJustDecodeBounds = true;
+		BitmapFactory.decodeStream(is, null, options);
+		String mimeType = options.outMimeType;
+		if (mimeType == null) mimeType = "";
+		return new DecodeResult(options.outWidth, options.outHeight,
+				mimeType);
+	}
+
+	@Nullable
+	@Override
+	public String getExtensionFromMimeType(String mimeType) {
+		MimeTypeMap mimeTypeMap = MimeTypeMap.getSingleton();
+		return mimeTypeMap.getExtensionFromMimeType(mimeType);
+	}
+}

briar-android/src/main/java/org/briarproject/briar/android/attachment/ImageSizeCalculator.java

@@ -0,0 +1,94 @@
+package org.briarproject.briar.android.attachment;
+
+import android.support.media.ExifInterface;
+
+import com.bumptech.glide.util.MarkEnforcingInputStream;
+
+import org.briarproject.bramble.api.nullsafety.NotNullByDefault;
+import org.briarproject.briar.android.attachment.ImageHelper.DecodeResult;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.logging.Logger;
+
+import static android.support.media.ExifInterface.ORIENTATION_ROTATE_270;
+import static android.support.media.ExifInterface.ORIENTATION_ROTATE_90;
+import static android.support.media.ExifInterface.ORIENTATION_TRANSPOSE;
+import static android.support.media.ExifInterface.ORIENTATION_TRANSVERSE;
+import static android.support.media.ExifInterface.TAG_IMAGE_LENGTH;
+import static android.support.media.ExifInterface.TAG_IMAGE_WIDTH;
+import static android.support.media.ExifInterface.TAG_ORIENTATION;
+import static java.util.logging.Level.WARNING;
+import static java.util.logging.Logger.getLogger;
+import static org.briarproject.bramble.util.LogUtils.logException;
+
+@NotNullByDefault
+class ImageSizeCalculator {
+
+	private static final Logger LOG =
+			getLogger(ImageSizeCalculator.class.getName());
+
+	private static final int READ_LIMIT = 1024 * 8192;
+
+	private final ImageHelper imageHelper;
+
+	ImageSizeCalculator(ImageHelper imageHelper) {
+		this.imageHelper = imageHelper;
+	}
+
+	Size getSize(InputStream is, String contentType) {
+		Size size = new Size();
+		is = new MarkEnforcingInputStream(is);
+		is.mark(READ_LIMIT);
+		if (contentType.equals("image/jpeg")) {
+			try {
+				// use exif to get size
+				size = getSizeFromExif(is);
+				is.reset();
+			} catch (IOException e) {
+				logException(LOG, WARNING, e);
+			}
+		}
+		if (size.error) {
+			// need to mark again to re-add read limit
+			is.mark(READ_LIMIT);
+			try {
+				// use BitmapFactory to get size
+				size = getSizeFromBitmap(is);
+				is.reset();
+			} catch (IOException e) {
+				logException(LOG, WARNING, e);
+			}
+		}
+		return size;
+	}
+
+	/**
+	 * Gets the size of a JPEG {@link InputStream} if EXIF info is available.
+	 */
+	private Size getSizeFromExif(InputStream is) throws IOException {
+		ExifInterface exif = new ExifInterface(is);
+		// these can return 0 independent of default value
+		int width = exif.getAttributeInt(TAG_IMAGE_WIDTH, 0);
+		int height = exif.getAttributeInt(TAG_IMAGE_LENGTH, 0);
+		if (width == 0 || height == 0) return new Size();
+		int orientation = exif.getAttributeInt(TAG_ORIENTATION, 0);
+		if (orientation == ORIENTATION_ROTATE_90 ||
+				orientation == ORIENTATION_ROTATE_270 ||
+				orientation == ORIENTATION_TRANSVERSE ||
+				orientation == ORIENTATION_TRANSPOSE) {
+			//noinspection SuspiciousNameCombination
+			return new Size(height, width, "image/jpeg");
+		}
+		return new Size(width, height, "image/jpeg");
+	}
+
+	/**
+	 * Gets the size of any image {@link InputStream}.
+	 */
+	private Size getSizeFromBitmap(InputStream is) {
+		DecodeResult result = imageHelper.decodeStream(is);
+		if (result.width < 1 || result.height < 1) return new Size();
+		return new Size(result.width, result.height, result.mimeType);
+	}
+}

briar-android/src/main/java/org/briarproject/briar/android/attachment/Size.java

@@ -0,0 +1,23 @@
+package org.briarproject.briar.android.attachment;
+
+class Size {
+
+	final int width;
+	final int height;
+	final String mimeType;
+	final boolean error;
+
+	Size(int width, int height, String mimeType) {
+		this.width = width;
+		this.height = height;
+		this.mimeType = mimeType;
+		this.error = false;
+	}
+
+	Size() {
+		this.width = 0;
+		this.height = 0;
+		this.mimeType = "";
+		this.error = true;
+	}
+}

briar-android/src/main/java/org/briarproject/briar/android/conversation/ConversationViewModel.java

@@ -18,7 +18,6 @@ import org.briarproject.bramble.api.db.DbException;
 import org.briarproject.bramble.api.db.NoSuchContactException;
 import org.briarproject.bramble.api.db.TransactionManager;
 import org.briarproject.bramble.api.identity.AuthorId;
-import org.briarproject.bramble.api.lifecycle.IoExecutor;
 import org.briarproject.bramble.api.nullsafety.NotNullByDefault;
 import org.briarproject.bramble.api.settings.Settings;
 import org.briarproject.bramble.api.settings.SettingsManager;
@@ -51,7 +50,6 @@ import static java.util.logging.Logger.getLogger;
 import static org.briarproject.bramble.util.LogUtils.logDuration;
 import static org.briarproject.bramble.util.LogUtils.logException;
 import static org.briarproject.bramble.util.LogUtils.now;
-import static org.briarproject.briar.android.attachment.AttachmentDimensions.getAttachmentDimensions;
 import static org.briarproject.briar.android.settings.SettingsFragment.SETTINGS_NAMESPACE;
 import static org.briarproject.briar.android.util.UiUtils.observeForeverOnce;
 
@@ -101,10 +99,13 @@ public class ConversationViewModel extends AndroidViewModel
 	@Inject
 	ConversationViewModel(Application application,
 			@DatabaseExecutor Executor dbExecutor,
-			@IoExecutor Executor ioExecutor, TransactionManager db,
-			MessagingManager messagingManager, ContactManager contactManager,
+			TransactionManager db,
+			MessagingManager messagingManager,
+			ContactManager contactManager,
 			SettingsManager settingsManager,
-			PrivateMessageFactory privateMessageFactory) {
+			PrivateMessageFactory privateMessageFactory,
+			AttachmentRetriever attachmentRetriever,
+			AttachmentCreator attachmentCreator) {
 		super(application);
 		this.dbExecutor = dbExecutor;
 		this.db = db;
@@ -112,10 +113,8 @@ public class ConversationViewModel extends AndroidViewModel
 		this.contactManager = contactManager;
 		this.settingsManager = settingsManager;
 		this.privateMessageFactory = privateMessageFactory;
-		this.attachmentRetriever = new AttachmentRetriever(messagingManager,
-				getAttachmentDimensions(application.getResources()));
-		this.attachmentCreator = new AttachmentCreator(getApplication(),
-				ioExecutor, messagingManager, attachmentRetriever);
+		this.attachmentRetriever = attachmentRetriever;
+		this.attachmentCreator = attachmentCreator;
 		messagingGroupId = Transformations
 				.map(contact, c -> messagingManager.getContactGroup(c).getId());
 		contactDeleted.setValue(false);