bramble-api/src/main/java/org/briarproject/bramble/api/battery/event/BatteryEvent.java

+package org.briarproject.bramble.api.battery.event;
+
+import org.briarproject.bramble.api.event.Event;
+
+/**
+ * An event that is broadcast when the device starts or stops charging.
+ */
+public class BatteryEvent extends Event {
+
+	private final boolean charging;
+
+	public BatteryEvent(boolean charging) {
+		this.charging = charging;
+	}
+
+	public boolean isCharging() {
+		return charging;
+	}
+}

bramble-api/src/main/java/org/briarproject/bramble/api/cleanup/CleanupHook.java

+package org.briarproject.bramble.api.cleanup;
+
+import org.briarproject.bramble.api.db.DatabaseComponent;
+import org.briarproject.bramble.api.db.DbException;
+import org.briarproject.bramble.api.db.Transaction;
+import org.briarproject.bramble.api.sync.GroupId;
+import org.briarproject.bramble.api.sync.MessageId;
+import org.briarproject.nullsafety.NotNullByDefault;
+
+import java.util.Collection;
+
+/**
+ * An interface for registering a hook with the {@link CleanupManager}
+ * that will be called when a message's cleanup deadline is reached.
+ */
+@NotNullByDefault
+public interface CleanupHook {
+
+	/**
+	 * Called when the cleanup deadlines of one or more messages are reached.
+	 * <p>
+	 * The callee is not required to delete the messages, but the hook won't be
+	 * called again for these messages unless another cleanup timer is set (see
+	 * {@link DatabaseComponent#setCleanupTimerDuration(Transaction, MessageId, long)}
+	 * and {@link DatabaseComponent#startCleanupTimer(Transaction, MessageId)}).
+	 */
+	void deleteMessages(Transaction txn, GroupId g,
+			Collection<MessageId> messageIds) throws DbException;
+}

bramble-api/src/main/java/org/briarproject/bramble/api/cleanup/CleanupManager.java

+package org.briarproject.bramble.api.cleanup;
+
+import org.briarproject.bramble.api.cleanup.event.CleanupTimerStartedEvent;
+import org.briarproject.bramble.api.crypto.SecretKey;
+import org.briarproject.bramble.api.db.DatabaseComponent;
+import org.briarproject.bramble.api.db.Transaction;
+import org.briarproject.bramble.api.lifecycle.LifecycleManager;
+import org.briarproject.bramble.api.sync.ClientId;
+import org.briarproject.bramble.api.sync.MessageId;
+import org.briarproject.nullsafety.NotNullByDefault;
+
+/**
+ * The CleanupManager is responsible for tracking the cleanup deadlines of
+ * messages and passing them to their respective
+ * {@link CleanupHook CleanupHooks} when the deadlines are reached.
+ * <p>
+ * The CleanupManager responds to
+ * {@link CleanupTimerStartedEvent CleanupTimerStartedEvents} broadcast by the
+ * {@link DatabaseComponent}.
+ * <p>
+ * See {@link DatabaseComponent#setCleanupTimerDuration(Transaction, MessageId, long)},
+ * {@link DatabaseComponent#startCleanupTimer(Transaction, MessageId)},
+ * {@link DatabaseComponent#stopCleanupTimer(Transaction, MessageId)}.
+ */
+@NotNullByDefault
+public interface CleanupManager {
+
+	/**
+	 * When scheduling a cleanup task we overshoot the deadline by this many
+	 * milliseconds to reduce the number of tasks that need to be scheduled
+	 * when messages have cleanup deadlines that are close together.
+	 */
+	long BATCH_DELAY_MS = 1000;
+
+	/**
+	 * Registers a hook to be called when messages are due for cleanup.
+	 * This method should be called before
+	 * {@link LifecycleManager#startServices(SecretKey)}.
+	 */
+	void registerCleanupHook(ClientId c, int majorVersion,
+			CleanupHook hook);
+}

bramble-api/src/main/java/org/briarproject/bramble/api/cleanup/event/CleanupTimerStartedEvent.java

+package org.briarproject.bramble.api.cleanup.event;
+
+import org.briarproject.bramble.api.event.Event;
+import org.briarproject.bramble.api.sync.MessageId;
+import org.briarproject.nullsafety.NotNullByDefault;
+
+import javax.annotation.concurrent.Immutable;
+
+/**
+ * An event that is broadcast when a message's cleanup timer is started.
+ */
+@Immutable
+@NotNullByDefault
+public class CleanupTimerStartedEvent extends Event {
+
+	private final MessageId messageId;
+	private final long cleanupDeadline;
+
+	public CleanupTimerStartedEvent(MessageId messageId,
+			long cleanupDeadline) {
+		this.messageId = messageId;
+		this.cleanupDeadline = cleanupDeadline;
+	}
+
+	public MessageId getMessageId() {
+		return messageId;
+	}
+
+	public long getCleanupDeadline() {
+		return cleanupDeadline;
+	}
+}

bramble-api/src/main/java/org/briarproject/bramble/api/client/BdfIncomingMessageHook.java

+package org.briarproject.bramble.api.client;
+
+import org.briarproject.bramble.api.FormatException;
+import org.briarproject.bramble.api.data.BdfDictionary;
+import org.briarproject.bramble.api.data.BdfList;
+import org.briarproject.bramble.api.data.MetadataParser;
+import org.briarproject.bramble.api.db.DatabaseComponent;
+import org.briarproject.bramble.api.db.DbException;
+import org.briarproject.bramble.api.db.Metadata;
+import org.briarproject.bramble.api.db.Transaction;
+import org.briarproject.bramble.api.sync.InvalidMessageException;
+import org.briarproject.bramble.api.sync.Message;
+import org.briarproject.bramble.api.sync.validation.IncomingMessageHook;
+import org.briarproject.nullsafety.NotNullByDefault;
+
+import javax.annotation.concurrent.Immutable;
+
+@Immutable
+@NotNullByDefault
+public abstract class BdfIncomingMessageHook implements IncomingMessageHook {
+
+	protected final DatabaseComponent db;
+	protected final ClientHelper clientHelper;
+	protected final MetadataParser metadataParser;
+
+	protected BdfIncomingMessageHook(DatabaseComponent db,
+			ClientHelper clientHelper, MetadataParser metadataParser) {
+		this.db = db;
+		this.clientHelper = clientHelper;
+		this.metadataParser = metadataParser;
+	}
+
+	/**
+	 * Called once for each incoming message that passes validation.
+	 * <p>
+	 * If an unexpected exception occurs while handling data that is assumed
+	 * to be valid (e.g. locally created metadata), it may be sensible to
+	 * rethrow the unexpected exception as a DbException so that delivery is
+	 * attempted again at next startup. This will allow delivery to succeed if
+	 * the unexpected exception was caused by a bug that has subsequently been
+	 * fixed.
+	 *
+	 * @param txn A read-write transaction
+	 * @throws DbException if a database error occurs while delivering the
+	 * message. Delivery will be attempted again at next startup. Throwing
+	 * this exception has the same effect as returning
+	 * {@link DeliveryAction#DEFER}.
+	 * @throws FormatException if the message is invalid in the context of its
+	 * dependencies. The message and any dependents will be marked as invalid
+	 * and deleted along with their metadata. Throwing this exception has the
+	 * same effect as returning {@link DeliveryAction#REJECT}.
+	 */
+	protected abstract DeliveryAction incomingMessage(Transaction txn,
+			Message m, BdfList body, BdfDictionary meta)
+			throws DbException, FormatException;
+
+	@Override
+	public DeliveryAction incomingMessage(Transaction txn, Message m,
+			Metadata meta) throws DbException, InvalidMessageException {
+		try {
+			BdfList body = clientHelper.toList(m);
+			BdfDictionary metaDictionary = metadataParser.parse(meta);
+			return incomingMessage(txn, m, body, metaDictionary);
+		} catch (FormatException e) {
+			throw new InvalidMessageException(e);
+		}
+	}
+}

bramble-api/src/main/java/org/briarproject/bramble/api/client/BdfMessageContext.java

+package org.briarproject.bramble.api.client;
+
+import org.briarproject.bramble.api.data.BdfDictionary;
+import org.briarproject.bramble.api.sync.MessageId;
+import org.briarproject.nullsafety.NotNullByDefault;
+
+import java.util.Collection;
+import java.util.Collections;
+
+import javax.annotation.concurrent.Immutable;
+
+@Immutable
+@NotNullByDefault
+public class BdfMessageContext {
+
+	private final BdfDictionary dictionary;
+	private final Collection<MessageId> dependencies;
+
+	public BdfMessageContext(BdfDictionary dictionary,
+			Collection<MessageId> dependencies) {
+		this.dictionary = dictionary;
+		this.dependencies = dependencies;
+	}
+
+	public BdfMessageContext(BdfDictionary dictionary) {
+		this(dictionary, Collections.emptyList());
+	}
+
+	public BdfDictionary getDictionary() {
+		return dictionary;
+	}
+
+	public Collection<MessageId> getDependencies() {
+		return dependencies;
+	}
+}

bramble-api/src/main/java/org/briarproject/bramble/api/client/BdfMessageValidator.java

+package org.briarproject.bramble.api.client;
+
+import org.briarproject.bramble.api.FormatException;
+import org.briarproject.bramble.api.data.BdfList;
+import org.briarproject.bramble.api.data.MetadataEncoder;
+import org.briarproject.bramble.api.db.Metadata;
+import org.briarproject.bramble.api.sync.Group;
+import org.briarproject.bramble.api.sync.InvalidMessageException;
+import org.briarproject.bramble.api.sync.Message;
+import org.briarproject.bramble.api.sync.MessageContext;
+import org.briarproject.bramble.api.sync.validation.MessageValidator;
+import org.briarproject.bramble.api.system.Clock;
+import org.briarproject.nullsafety.NotNullByDefault;
+
+import java.util.logging.Logger;
+
+import javax.annotation.concurrent.Immutable;
+
+import static java.util.logging.Logger.getLogger;
+import static org.briarproject.bramble.api.transport.TransportConstants.MAX_CLOCK_DIFFERENCE;
+
+@Immutable
+@NotNullByDefault
+public abstract class BdfMessageValidator implements MessageValidator {
+
+	protected static final Logger LOG =
+			getLogger(BdfMessageValidator.class.getName());
+
+	protected final ClientHelper clientHelper;
+	protected final MetadataEncoder metadataEncoder;
+	protected final Clock clock;
+	protected final boolean canonical;
+
+	/**
+	 * Transitional alternative to
+	 * {@link #BdfMessageValidator(ClientHelper, MetadataEncoder, Clock)} that
+	 * accepts messages in non-canonical form, for backward compatibility.
+	 */
+	@Deprecated
+	protected BdfMessageValidator(ClientHelper clientHelper,
+			MetadataEncoder metadataEncoder, Clock clock, boolean canonical) {
+		this.clientHelper = clientHelper;
+		this.metadataEncoder = metadataEncoder;
+		this.clock = clock;
+		this.canonical = canonical;
+	}
+
+	protected BdfMessageValidator(ClientHelper clientHelper,
+			MetadataEncoder metadataEncoder, Clock clock) {
+		this(clientHelper, metadataEncoder, clock, true);
+	}
+
+	protected abstract BdfMessageContext validateMessage(Message m, Group g,
+			BdfList body) throws InvalidMessageException, FormatException;
+
+	@Override
+	public MessageContext validateMessage(Message m, Group g)
+			throws InvalidMessageException {
+		// Reject the message if it's too far in the future
+		long now = clock.currentTimeMillis();
+		if (m.getTimestamp() - now > MAX_CLOCK_DIFFERENCE) {
+			throw new InvalidMessageException(
+					"Timestamp is too far in the future");
+		}
+		try {
+			BdfList bodyList = clientHelper.toList(m, canonical);
+			BdfMessageContext result = validateMessage(m, g, bodyList);
+			Metadata meta = metadataEncoder.encode(result.getDictionary());
+			return new MessageContext(meta, result.getDependencies());
+		} catch (FormatException e) {
+			throw new InvalidMessageException(e);
+		}
+	}
+}

bramble-api/src/main/java/org/briarproject/bramble/api/client/ClientHelper.java

+package org.briarproject.bramble.api.client;
+
+import org.briarproject.bramble.api.FormatException;
+import org.briarproject.bramble.api.contact.ContactId;
+import org.briarproject.bramble.api.crypto.PrivateKey;
+import org.briarproject.bramble.api.crypto.PublicKey;
+import org.briarproject.bramble.api.data.BdfDictionary;
+import org.briarproject.bramble.api.data.BdfList;
+import org.briarproject.bramble.api.db.DbException;
+import org.briarproject.bramble.api.db.Transaction;
+import org.briarproject.bramble.api.identity.Author;
+import org.briarproject.bramble.api.mailbox.MailboxUpdate;
+import org.briarproject.bramble.api.mailbox.MailboxVersion;
+import org.briarproject.bramble.api.plugin.TransportId;
+import org.briarproject.bramble.api.properties.TransportProperties;
+import org.briarproject.bramble.api.sync.GroupId;
+import org.briarproject.bramble.api.sync.Message;
+import org.briarproject.bramble.api.sync.MessageId;
+import org.briarproject.nullsafety.NotNullByDefault;
+
+import java.security.GeneralSecurityException;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+
+@NotNullByDefault
+public interface ClientHelper {
+
+	void addLocalMessage(Message m, BdfDictionary metadata, boolean shared)
+			throws DbException, FormatException;
+
+	void addLocalMessage(Transaction txn, Message m, BdfDictionary metadata,
+			boolean shared, boolean temporary)
+			throws DbException, FormatException;
+
+	Message createMessage(GroupId g, long timestamp, byte[] body);
+
+	Message createMessage(GroupId g, long timestamp, BdfList body)
+			throws FormatException;
+
+	Message createMessageForStoringMetadata(GroupId g);
+
+	Message getMessage(MessageId m) throws DbException;
+
+	Message getMessage(Transaction txn, MessageId m) throws DbException;
+
+	BdfList getMessageAsList(MessageId m) throws DbException, FormatException;
+
+	BdfList getMessageAsList(Transaction txn, MessageId m) throws DbException,
+			FormatException;
+
+	/**
+	 * Transitional alternative to
+	 * {@link #getMessageAsList(Transaction, MessageId)} that allows the
+	 * message to be in non-canonical form, for backward compatibility.
+	 *
+	 * @param canonical True if the message must be in canonical form (a
+	 * {@link FormatException} will be thrown if it's not.
+	 */
+	@Deprecated
+	BdfList getMessageAsList(Transaction txn, MessageId m, boolean canonical)
+			throws DbException, FormatException;
+
+	BdfDictionary getGroupMetadataAsDictionary(GroupId g) throws DbException,
+			FormatException;
+
+	BdfDictionary getGroupMetadataAsDictionary(Transaction txn, GroupId g)
+			throws DbException, FormatException;
+
+	Collection<MessageId> getMessageIds(Transaction txn, GroupId g,
+			BdfDictionary query) throws DbException, FormatException;
+
+	BdfDictionary getMessageMetadataAsDictionary(MessageId m)
+			throws DbException, FormatException;
+
+	BdfDictionary getMessageMetadataAsDictionary(Transaction txn, MessageId m)
+			throws DbException, FormatException;
+
+	Map<MessageId, BdfDictionary> getMessageMetadataAsDictionary(GroupId g)
+			throws DbException, FormatException;
+
+	Map<MessageId, BdfDictionary> getMessageMetadataAsDictionary(
+			Transaction txn, GroupId g) throws DbException, FormatException;
+
+	Map<MessageId, BdfDictionary> getMessageMetadataAsDictionary(GroupId g,
+			BdfDictionary query) throws DbException, FormatException;
+
+	Map<MessageId, BdfDictionary> getMessageMetadataAsDictionary(
+			Transaction txn, GroupId g, BdfDictionary query) throws DbException,
+			FormatException;
+
+	void mergeGroupMetadata(GroupId g, BdfDictionary metadata)
+			throws DbException, FormatException;
+
+	void mergeGroupMetadata(Transaction txn, GroupId g, BdfDictionary metadata)
+			throws DbException, FormatException;
+
+	void mergeMessageMetadata(MessageId m, BdfDictionary metadata)
+			throws DbException, FormatException;
+
+	void mergeMessageMetadata(Transaction txn, MessageId m,
+			BdfDictionary metadata) throws DbException, FormatException;
+
+	byte[] toByteArray(BdfDictionary dictionary) throws FormatException;
+
+	byte[] toByteArray(BdfList list) throws FormatException;
+
+	BdfDictionary toDictionary(byte[] b, int off, int len)
+			throws FormatException;
+
+	BdfDictionary toDictionary(TransportProperties transportProperties);
+
+	BdfDictionary toDictionary(Map<TransportId, TransportProperties> map);
+
+	BdfList toList(byte[] b, int off, int len) throws FormatException;
+
+	BdfList toList(byte[] b) throws FormatException;
+
+	BdfList toList(Message m) throws FormatException;
+
+	/**
+	 * Transitional alternative to {@link #toList(Message)} that allows the
+	 * message to be in non-canonical form, for backward compatibility.
+	 *
+	 * @param canonical True if the message must be in canonical form (a
+	 * {@link FormatException} will be thrown if it's not.
+	 */
+	@Deprecated
+	BdfList toList(Message m, boolean canonical) throws FormatException;
+
+	BdfList toList(Author a);
+
+	byte[] sign(String label, BdfList toSign, PrivateKey privateKey)
+			throws FormatException, GeneralSecurityException;
+
+	void verifySignature(byte[] signature, String label, BdfList signed,
+			PublicKey publicKey)
+			throws FormatException, GeneralSecurityException;
+
+	Author parseAndValidateAuthor(BdfList author) throws FormatException;
+
+	PublicKey parseAndValidateAgreementPublicKey(byte[] publicKeyBytes)
+			throws FormatException;
+
+	TransportProperties parseAndValidateTransportProperties(
+			BdfDictionary properties) throws FormatException;
+
+	Map<TransportId, TransportProperties> parseAndValidateTransportPropertiesMap(
+			BdfDictionary properties) throws FormatException;
+
+	/**
+	 * Parse and validate the elements of a Mailbox update message.
+	 *
+	 * @return the parsed update message
+	 * @throws FormatException if the message elements are invalid
+	 */
+	MailboxUpdate parseAndValidateMailboxUpdate(BdfList clientSupports,
+			BdfList serverSupports, BdfDictionary properties)
+			throws FormatException;
+
+	List<MailboxVersion> parseMailboxVersionList(BdfList bdfList)
+			throws FormatException;
+
+	/**
+	 * Retrieves the contact ID from the group metadata of the given contact
+	 * group.
+	 */
+	ContactId getContactId(Transaction txn, GroupId contactGroupId)
+			throws DbException;
+
+	/**
+	 * Stores the given contact ID in the group metadata of the given contact
+	 * group.
+	 */
+	void setContactId(Transaction txn, GroupId contactGroupId, ContactId c)
+			throws DbException;
+}

bramble-api/src/main/java/org/briarproject/bramble/api/client/ContactGroupConstants.java

+package org.briarproject.bramble.api.client;
+
+public interface ContactGroupConstants {
+
+	/**
+	 * Group metadata key for associating a contact ID with a contact group.
+	 */
+	String GROUP_KEY_CONTACT_ID = "contactId";
+}

bramble-api/src/main/java/org/briarproject/bramble/api/client/ContactGroupFactory.java

+package org.briarproject.bramble.api.client;
+
+import org.briarproject.bramble.api.contact.Contact;
+import org.briarproject.bramble.api.identity.AuthorId;
+import org.briarproject.bramble.api.sync.ClientId;
+import org.briarproject.bramble.api.sync.Group;
+import org.briarproject.nullsafety.NotNullByDefault;
+
+@NotNullByDefault
+public interface ContactGroupFactory {
+
+	/**
+	 * Creates a group that is not shared with any contacts.
+	 */
+	Group createLocalGroup(ClientId clientId, int majorVersion);
+
+	/**
+	 * Creates a group for the given client to share with the given contact.
+	 */
+	Group createContactGroup(ClientId clientId, int majorVersion,
+			Contact contact);
+
+	/**
+	 * Creates a group for the given client to share between the given authors
+	 * identified by their AuthorIds.
+	 */
+	Group createContactGroup(ClientId clientId, int majorVersion,
+			AuthorId authorId1, AuthorId authorId2);
+
+}

bramble-api/src/main/java/org/briarproject/bramble/api/connection/ConnectionManager.java

+package org.briarproject.bramble.api.connection;
+
+import org.briarproject.bramble.api.contact.ContactId;
+import org.briarproject.bramble.api.contact.PendingContactId;
+import org.briarproject.bramble.api.plugin.TransportConnectionReader;
+import org.briarproject.bramble.api.plugin.TransportConnectionWriter;
+import org.briarproject.bramble.api.plugin.TransportId;
+import org.briarproject.bramble.api.plugin.duplex.DuplexTransportConnection;
+import org.briarproject.bramble.api.sync.OutgoingSessionRecord;
+import org.briarproject.nullsafety.NotNullByDefault;
+
+@NotNullByDefault
+public interface ConnectionManager {
+
+	/**
+	 * Manages an incoming connection from a contact over a simplex transport.
+	 */
+	void manageIncomingConnection(TransportId t, TransportConnectionReader r);
+
+	/**
+	 * Manages an incoming connection from a contact via a mailbox.
+	 * <p>
+	 * This method does not mark the tag as recognised until after the data
+	 * has been read from the {@link TransportConnectionReader}, at which
+	 * point the {@link TagController} is called to decide whether the tag
+	 * should be marked as recognised.
+	 */
+	void manageIncomingConnection(TransportId t, TransportConnectionReader r,
+			TagController c);
+
+	/**
+	 * Manages an incoming connection from a contact over a duplex transport.
+	 */
+	void manageIncomingConnection(TransportId t, DuplexTransportConnection d);
+
+	/**
+	 * Manages an incoming handshake connection from a pending contact over a
+	 * duplex transport.
+	 */
+	void manageIncomingConnection(PendingContactId p, TransportId t,
+			DuplexTransportConnection d);
+
+	/**
+	 * Manages an outgoing connection to a contact over a simplex transport.
+	 */
+	void manageOutgoingConnection(ContactId c, TransportId t,
+			TransportConnectionWriter w);
+
+	/**
+	 * Manages an outgoing connection to a contact via a mailbox. The IDs of
+	 * any messages sent or acked are added to the given
+	 * {@link OutgoingSessionRecord}.
+	 */
+	void manageOutgoingConnection(ContactId c, TransportId t,
+			TransportConnectionWriter w, OutgoingSessionRecord sessionRecord);
+
+	/**
+	 * Manages an outgoing connection to a contact over a duplex transport.
+	 */
+	void manageOutgoingConnection(ContactId c, TransportId t,
+			DuplexTransportConnection d);
+
+	/**
+	 * Manages an outgoing handshake connection to a pending contact over a
+	 * duplex transport.
+	 */
+	void manageOutgoingConnection(PendingContactId p, TransportId t,
+			DuplexTransportConnection d);
+
+	/**
+	 * An interface for controlling whether a tag should be marked as
+	 * recognised.
+	 */
+	interface TagController {
+		/**
+		 * This method is only called if a tag was read from the corresponding
+		 * {@link TransportConnectionReader} and recognised.
+		 *
+		 * @param exception True if an exception was thrown while reading from
+		 * the {@link TransportConnectionReader}, after successfully reading
+		 * and recognising the tag.
+		 * @return True if the tag should be marked as recognised.
+		 */
+		boolean shouldMarkTagAsRecognised(boolean exception);
+	}
+}

bramble-api/src/main/java/org/briarproject/bramble/api/connection/ConnectionRegistry.java

+package org.briarproject.bramble.api.connection;
+
+import org.briarproject.bramble.api.contact.ContactId;
+import org.briarproject.bramble.api.contact.PendingContactId;
+import org.briarproject.bramble.api.plugin.PluginConfig;
+import org.briarproject.bramble.api.plugin.TransportId;
+import org.briarproject.bramble.api.plugin.event.ConnectionClosedEvent;
+import org.briarproject.bramble.api.plugin.event.ConnectionOpenedEvent;
+import org.briarproject.bramble.api.plugin.event.ContactConnectedEvent;
+import org.briarproject.bramble.api.plugin.event.ContactDisconnectedEvent;
+import org.briarproject.bramble.api.rendezvous.event.RendezvousConnectionClosedEvent;
+import org.briarproject.bramble.api.rendezvous.event.RendezvousConnectionOpenedEvent;
+import org.briarproject.bramble.api.sync.Priority;
+import org.briarproject.nullsafety.NotNullByDefault;
+
+import java.util.Collection;
+
+/**
+ * Keeps track of which contacts are currently connected by which transports.
+ */
+@NotNullByDefault
+public interface ConnectionRegistry {
+
+	/**
+	 * Registers an incoming connection from the given contact over the given
+	 * transport. The connection's {@link Priority priority} can be set later
+	 * via {@link #setPriority(ContactId, TransportId, InterruptibleConnection,
+	 * Priority)} if a priority record is received from the contact.
+	 * <p>
+	 * Broadcasts {@link ConnectionOpenedEvent}. Also broadcasts
+	 * {@link ContactConnectedEvent} if this is the only connection with the
+	 * contact.
+	 */
+	void registerIncomingConnection(ContactId c, TransportId t,
+			InterruptibleConnection conn);
+
+	/**
+	 * Registers an outgoing connection to the given contact over the given
+	 * transport.
+	 * <p>
+	 * Broadcasts {@link ConnectionOpenedEvent}. Also broadcasts
+	 * {@link ContactConnectedEvent} if this is the only connection with the
+	 * contact.
+	 * <p>
+	 * If the registry has any "better" connections with the given contact, the
+	 * given connection will be interrupted. If the registry has any "worse"
+	 * connections with the given contact, those connections will be
+	 * interrupted.
+	 * <p>
+	 * Connection A is considered "better" than connection B if both
+	 * connections have had their priorities set, and either A's transport is
+	 * {@link PluginConfig#getTransportPreferences() preferred} to B's, or
+	 * they use the same transport and A has higher {@link Priority priority}
+	 * than B.
+	 * <p>
+	 * For backward compatibility, connections without priorities are not
+	 * considered better or worse than other connections.
+	 */
+	void registerOutgoingConnection(ContactId c, TransportId t,
+			InterruptibleConnection conn, Priority priority);
+
+	/**
+	 * Unregisters a connection with the given contact over the given transport.
+	 * <p>
+	 * Broadcasts {@link ConnectionClosedEvent}. Also broadcasts
+	 * {@link ContactDisconnectedEvent} if this is the only connection with
+	 * the contact.
+	 */
+	void unregisterConnection(ContactId c, TransportId t,
+			InterruptibleConnection conn, boolean incoming, boolean exception);
+
+	/**
+	 * Sets the {@link Priority priority} of a connection that was previously
+	 * registered via {@link #registerIncomingConnection(ContactId, TransportId,
+	 * InterruptibleConnection)}.
+	 * <p>
+	 * If the registry has any "better" connections with the given contact, the
+	 * given connection will be interrupted. If the registry has any "worse"
+	 * connections with the given contact, those connections will be
+	 * interrupted.
+	 * <p>
+	 * Connection A is considered "better" than connection B if both
+	 * connections have had their priorities set, and either A's transport is
+	 * {@link PluginConfig#getTransportPreferences() preferred} to B's, or
+	 * they use the same transport and A has higher {@link Priority priority}
+	 * than B.
+	 * <p>
+	 * For backward compatibility, connections without priorities are not
+	 * considered better or worse than other connections.
+	 */
+	void setPriority(ContactId c, TransportId t, InterruptibleConnection conn,
+			Priority priority);
+
+	/**
+	 * Returns any contacts that are connected via the given transport.
+	 */
+	Collection<ContactId> getConnectedContacts(TransportId t);
+
+	/**
+	 * Returns any contacts that are connected via the given transport or any
+	 * {@link PluginConfig#getTransportPreferences() better} transport.
+	 */
+	Collection<ContactId> getConnectedOrBetterContacts(TransportId t);
+
+	/**
+	 * Returns true if the given contact is connected via the given transport.
+	 */
+	boolean isConnected(ContactId c, TransportId t);
+
+	/**
+	 * Returns true if the given contact is connected via any transport.
+	 */
+	boolean isConnected(ContactId c);
+
+	/**
+	 * Registers a connection with the given pending contact. Broadcasts
+	 * {@link RendezvousConnectionOpenedEvent} if this is the only connection
+	 * with the pending contact.
+	 *
+	 * @return True if this is the only connection with the pending contact,
+	 * false if it is redundant and should be closed
+	 */
+	boolean registerConnection(PendingContactId p);
+
+	/**
+	 * Unregisters a connection with the given pending contact. Broadcasts
+	 * {@link RendezvousConnectionClosedEvent}.
+	 */
+	void unregisterConnection(PendingContactId p, boolean success);
+}

bramble-api/src/main/java/org/briarproject/bramble/api/connection/InterruptibleConnection.java

+package org.briarproject.bramble.api.connection;
+
+import org.briarproject.nullsafety.NotNullByDefault;
+
+/**
+ * A duplex sync connection that can be closed by interrupting its outgoing
+ * sync session.
+ */
+@NotNullByDefault
+public interface InterruptibleConnection {
+
+	/**
+	 * Interrupts the connection's outgoing sync session. If the underlying
+	 * transport connection is alive and the remote peer is cooperative, this
+	 * should result in both sync sessions ending and the connection being
+	 * cleanly closed.
+	 */
+	void interruptOutgoingSession();
+}

bramble-api/src/main/java/org/briarproject/bramble/api/contact/Contact.java

+package org.briarproject.bramble.api.contact;
+
+import org.briarproject.bramble.api.crypto.PublicKey;
+import org.briarproject.bramble.api.identity.Author;
+import org.briarproject.bramble.api.identity.AuthorId;
+import org.briarproject.nullsafety.NotNullByDefault;
+
+import javax.annotation.Nullable;
+import javax.annotation.concurrent.Immutable;
+
+import static org.briarproject.bramble.api.identity.AuthorConstants.MAX_AUTHOR_NAME_LENGTH;
+import static org.briarproject.bramble.util.StringUtils.toUtf8;
+
+@Immutable
+@NotNullByDefault
+public class Contact {
+
+	private final ContactId id;
+	private final Author author;
+	private final AuthorId localAuthorId;
+	@Nullable
+	private final String alias;
+	@Nullable
+	private final PublicKey handshakePublicKey;
+	private final boolean verified;
+
+	public Contact(ContactId id, Author author, AuthorId localAuthorId,
+			@Nullable String alias, @Nullable PublicKey handshakePublicKey,
+			boolean verified) {
+		if (alias != null) {
+			int aliasLength = toUtf8(alias).length;
+			if (aliasLength == 0 || aliasLength > MAX_AUTHOR_NAME_LENGTH)
+				throw new IllegalArgumentException();
+		}
+		this.id = id;
+		this.author = author;
+		this.localAuthorId = localAuthorId;
+		this.alias = alias;
+		this.handshakePublicKey = handshakePublicKey;
+		this.verified = verified;
+	}
+
+	public ContactId getId() {
+		return id;
+	}
+
+	public Author getAuthor() {
+		return author;
+	}
+
+	public AuthorId getLocalAuthorId() {
+		return localAuthorId;
+	}
+
+	@Nullable
+	public String getAlias() {
+		return alias;
+	}
+
+	@Nullable
+	public PublicKey getHandshakePublicKey() {
+		return handshakePublicKey;
+	}
+
+	public boolean isVerified() {
+		return verified;
+	}
+
+	@Override
+	public int hashCode() {
+		return id.hashCode();
+	}
+
+	@Override
+	public boolean equals(Object o) {
+		return o instanceof Contact && id.equals(((Contact) o).id);
+	}
+}

bramble-api/src/main/java/org/briarproject/bramble/api/contact/ContactExchangeManager.java

+package org.briarproject.bramble.api.contact;
+
+import org.briarproject.bramble.api.crypto.SecretKey;
+import org.briarproject.bramble.api.db.ContactExistsException;
+import org.briarproject.bramble.api.db.DbException;
+import org.briarproject.bramble.api.plugin.duplex.DuplexTransportConnection;
+import org.briarproject.nullsafety.NotNullByDefault;
+
+import java.io.IOException;
+
+@NotNullByDefault
+public interface ContactExchangeManager {
+
+	/**
+	 * Exchanges contact information with a remote peer and adds the peer
+	 * as a contact.
+	 *
+	 * @param alice Whether the local peer takes the role of Alice
+	 * @return The newly added contact
+	 * @throws ContactExistsException If the contact already exists
+	 */
+	Contact exchangeContacts(DuplexTransportConnection conn,
+			SecretKey masterKey, boolean alice, boolean verified)
+			throws IOException, DbException;
+
+	/**
+	 * Exchanges contact information with a remote peer and adds the peer
+	 * as a contact, replacing the given pending contact.
+	 *
+	 * @param alice Whether the local peer takes the role of Alice
+	 * @return The newly added contact
+	 * @throws ContactExistsException If the contact already exists
+	 */
+	Contact exchangeContacts(PendingContactId p, DuplexTransportConnection conn,
+			SecretKey masterKey, boolean alice, boolean verified)
+			throws IOException, DbException;
+}

bramble-api/src/main/java/org/briarproject/bramble/api/contact/ContactId.java

+package org.briarproject.bramble.api.contact;
+
+import org.briarproject.nullsafety.NotNullByDefault;
+
+import javax.annotation.Nullable;
+import javax.annotation.concurrent.Immutable;
+
+/**
+ * Type-safe wrapper for an integer that uniquely identifies a contact within
+ * the scope of the local device.
+ */
+@Immutable
+@NotNullByDefault
+public class ContactId {
+
+	private final int id;
+
+	public ContactId(int id) {
+		this.id = id;
+	}
+
+	public int getInt() {
+		return id;
+	}
+
+	@Override
+	public int hashCode() {
+		return id;
+	}
+
+	@Override
+	public boolean equals(@Nullable Object o) {
+		return o instanceof ContactId && id == ((ContactId) o).id;
+	}
+}

bramble-api/src/main/java/org/briarproject/bramble/api/contact/ContactManager.java

+package org.briarproject.bramble.api.contact;
+
+import org.briarproject.bramble.api.FormatException;
+import org.briarproject.bramble.api.Pair;
+import org.briarproject.bramble.api.UnsupportedVersionException;
+import org.briarproject.bramble.api.crypto.SecretKey;
+import org.briarproject.bramble.api.db.ContactExistsException;
+import org.briarproject.bramble.api.db.DbException;
+import org.briarproject.bramble.api.db.NoSuchContactException;
+import org.briarproject.bramble.api.db.PendingContactExistsException;
+import org.briarproject.bramble.api.db.Transaction;
+import org.briarproject.bramble.api.identity.Author;
+import org.briarproject.bramble.api.identity.AuthorId;
+import org.briarproject.bramble.api.lifecycle.LifecycleManager;
+import org.briarproject.nullsafety.NotNullByDefault;
+
+import java.security.GeneralSecurityException;
+import java.util.Collection;
+
+import javax.annotation.Nullable;
+
+@NotNullByDefault
+public interface ContactManager {
+
+	/**
+	 * Registers a hook to be called whenever a contact is added or removed.
+	 * This method should be called before
+	 * {@link LifecycleManager#startServices(SecretKey)}.
+	 */
+	void registerContactHook(ContactHook hook);
+
+	/**
+	 * Stores a contact associated with the given local and remote pseudonyms,
+	 * derives and stores rotation mode transport keys for each transport, and
+	 * returns an ID for the contact.
+	 *
+	 * @param rootKey The root key for a set of rotation mode transport keys
+	 * @param timestamp The timestamp for deriving rotation mode transport
+	 * keys from the root key
+	 * @param alice True if the local party is Alice
+	 * @param verified True if the contact's identity has been verified, which
+	 * is true if the contact was added in person or false if the contact was
+	 * introduced or added remotely
+	 * @param active True if the rotation mode transport keys can be used for
+	 * outgoing streams
+	 */
+	ContactId addContact(Transaction txn, Author remote, AuthorId local,
+			SecretKey rootKey, long timestamp, boolean alice, boolean verified,
+			boolean active) throws DbException;
+
+	/**
+	 * Stores a contact associated with the given local and remote pseudonyms,
+	 * replacing the given pending contact, derives and stores handshake mode
+	 * and rotation mode transport keys for each transport, and returns an ID
+	 * for the contact.
+	 *
+	 * @param rootKey The root key for a set of rotation mode transport keys
+	 * @param timestamp The timestamp for deriving rotation mode transport
+	 * keys from the root key
+	 * @param alice True if the local party is Alice
+	 * @param verified True if the contact's identity has been verified, which
+	 * is true if the contact was added in person or false if the contact was
+	 * introduced or added remotely
+	 * @param active True if the rotation mode transport keys can be used for
+	 * outgoing streams
+	 * @throws GeneralSecurityException If the pending contact's handshake
+	 * public key is invalid
+	 */
+	ContactId addContact(Transaction txn, PendingContactId p, Author remote,
+			AuthorId local, SecretKey rootKey, long timestamp, boolean alice,
+			boolean verified, boolean active)
+			throws DbException, GeneralSecurityException;
+
+	/**
+	 * Stores a contact associated with the given local and remote pseudonyms
+	 * and returns an ID for the contact.
+	 *
+	 * @param verified True if the contact's identity has been verified, which
+	 * is true if the contact was added in person or false if the contact was
+	 * introduced or added remotely
+	 */
+	ContactId addContact(Transaction txn, Author remote, AuthorId local,
+			boolean verified) throws DbException;
+
+	/**
+	 * Stores a contact associated with the given local and remote pseudonyms,
+	 * derives and stores rotation mode transport keys for each transport, and
+	 * returns an ID for the contact.
+	 *
+	 * @param rootKey The root key for a set of rotation mode transport keys
+	 * @param timestamp The timestamp for deriving rotation mode transport
+	 * keys from the root key
+	 * @param alice True if the local party is Alice
+	 * @param verified True if the contact's identity has been verified, which
+	 * is true if the contact was added in person or false if the contact was
+	 * introduced or added remotely
+	 * @param active True if the rotation mode transport keys can be used for
+	 * outgoing streams
+	 */
+	ContactId addContact(Author remote, AuthorId local, SecretKey rootKey,
+			long timestamp, boolean alice, boolean verified, boolean active)
+			throws DbException;
+
+	/**
+	 * Returns the handshake link that needs to be sent to a contact we want
+	 * to add.
+	 */
+	String getHandshakeLink() throws DbException;
+
+	/**
+	 * Returns the handshake link that needs to be sent to a contact we want
+	 * to add.
+	 */
+	String getHandshakeLink(Transaction txn) throws DbException;
+
+	/**
+	 * Creates a {@link PendingContact} from the given handshake link and
+	 * alias, adds it to the database and returns it.
+	 *
+	 * @param link The handshake link received from the pending contact
+	 * @param alias The alias the user has given this pending contact
+	 * @throws UnsupportedVersionException If the link uses a format version
+	 * that is not supported
+	 * @throws FormatException If the link is invalid
+	 * @throws GeneralSecurityException If the pending contact's handshake
+	 * public key is invalid
+	 * @throws ContactExistsException If a contact with the same handshake
+	 * public key already exists
+	 * @throws PendingContactExistsException If a pending contact with the same
+	 * handshake public key already exists
+	 */
+	PendingContact addPendingContact(Transaction txn, String link, String alias)
+			throws DbException, FormatException, GeneralSecurityException,
+			ContactExistsException, PendingContactExistsException;
+
+	/**
+	 * Creates a {@link PendingContact} from the given handshake link and
+	 * alias, adds it to the database and returns it.
+	 *
+	 * @param link The handshake link received from the pending contact
+	 * @param alias The alias the user has given this pending contact
+	 * @throws UnsupportedVersionException If the link uses a format version
+	 * that is not supported
+	 * @throws FormatException If the link is invalid
+	 * @throws GeneralSecurityException If the pending contact's handshake
+	 * public key is invalid
+	 * @throws ContactExistsException If a contact with the same handshake
+	 * public key already exists
+	 * @throws PendingContactExistsException If a pending contact with the same
+	 * handshake public key already exists
+	 */
+	PendingContact addPendingContact(String link, String alias)
+			throws DbException, FormatException, GeneralSecurityException,
+			ContactExistsException, PendingContactExistsException;
+
+	/**
+	 * Returns the pending contact with the given ID.
+	 */
+	PendingContact getPendingContact(Transaction txn, PendingContactId p)
+			throws DbException;
+
+	/**
+	 * Returns a list of {@link PendingContact PendingContacts} and their
+	 * {@link PendingContactState states}.
+	 */
+	Collection<Pair<PendingContact, PendingContactState>> getPendingContacts()
+			throws DbException;
+
+	/**
+	 * Returns a list of {@link PendingContact PendingContacts} and their
+	 * {@link PendingContactState states}.
+	 */
+	Collection<Pair<PendingContact, PendingContactState>> getPendingContacts(Transaction txn)
+			throws DbException;
+
+	/**
+	 * Removes a {@link PendingContact}.
+	 */
+	void removePendingContact(PendingContactId p) throws DbException;
+
+	/**
+	 * Removes a {@link PendingContact}.
+	 */
+	void removePendingContact(Transaction txn, PendingContactId p)
+			throws DbException;
+
+	/**
+	 * Returns the contact with the given ID.
+	 */
+	Contact getContact(ContactId c) throws DbException;
+
+	/**
+	 * Returns the contact with the given ID.
+	 */
+	Contact getContact(Transaction txn, ContactId c) throws DbException;
+
+	/**
+	 * Returns the contact with the given {@code remoteAuthorId}
+	 * that belongs to the local pseudonym with the given {@code localAuthorId}.
+	 *
+	 * @throws NoSuchContactException If the contact is not in the database
+	 */
+	Contact getContact(AuthorId remoteAuthorId, AuthorId localAuthorId)
+			throws DbException;
+
+	/**
+	 * Returns the contact with the given {@code remoteAuthorId}
+	 * that belongs to the local pseudonym with the given {@code localAuthorId}.
+	 *
+	 * @throws NoSuchContactException If the contact is not in the database
+	 */
+	Contact getContact(Transaction txn, AuthorId remoteAuthorId,
+			AuthorId localAuthorId) throws DbException;
+
+	/**
+	 * Returns all contacts.
+	 */
+	Collection<Contact> getContacts() throws DbException;
+
+	/**
+	 * Returns all contacts.
+	 */
+	Collection<Contact> getContacts(Transaction txn) throws DbException;
+
+	/**
+	 * Removes a contact and all associated state.
+	 */
+	void removeContact(ContactId c) throws DbException;
+
+	/**
+	 * Removes a contact and all associated state.
+	 */
+	void removeContact(Transaction txn, ContactId c) throws DbException;
+
+	/**
+	 * Sets an alias for the contact or unsets it if {@code alias} is null.
+	 */
+	void setContactAlias(Transaction txn, ContactId c, @Nullable String alias)
+			throws DbException;
+
+	/**
+	 * Sets an alias for the contact or unsets it if {@code alias} is null.
+	 */
+	void setContactAlias(ContactId c, @Nullable String alias)
+			throws DbException;
+
+	/**
+	 * Returns true if a contact with this {@code remoteAuthorId} belongs to
+	 * the local pseudonym with this {@code localAuthorId}.
+	 */
+	boolean contactExists(Transaction txn, AuthorId remoteAuthorId,
+			AuthorId localAuthorId) throws DbException;
+
+	/**
+	 * Returns true if a contact with this {@code remoteAuthorId} belongs to
+	 * the local pseudonym with this {@code localAuthorId}.
+	 */
+	boolean contactExists(AuthorId remoteAuthorId, AuthorId localAuthorId)
+			throws DbException;
+
+	interface ContactHook {
+
+		/**
+		 * Called when a contact is being added.
+		 *
+		 * @param txn A read-write transaction
+		 * @param c The contact that is being added
+		 */
+		void addingContact(Transaction txn, Contact c) throws DbException;
+
+		/**
+		 * Called when a contact is being removed
+		 *
+		 * @param txn A read-write transaction
+		 * @param c The contact that is being removed
+		 */
+		void removingContact(Transaction txn, Contact c) throws DbException;
+	}
+}

bramble-api/src/main/java/org/briarproject/bramble/api/contact/HandshakeLinkConstants.java

+package org.briarproject.bramble.api.contact;
+
+import java.util.regex.Pattern;
+
+public interface HandshakeLinkConstants {
+
+	/**
+	 * The current version of the handshake link format.
+	 */
+	int FORMAT_VERSION = 0;
+
+	/**
+	 * The length of a base32-encoded handshake link in bytes, excluding the
+	 * 'briar://' prefix.
+	 */
+	int BASE32_LINK_BYTES = 53;
+
+	/**
+	 * The length of a raw handshake link in bytes, before base32 encoding.
+	 */
+	int RAW_LINK_BYTES = 33;
+
+	/**
+	 * Regular expression for matching handshake links, including or excluding
+	 * the 'briar://' prefix.
+	 */
+	Pattern LINK_REGEX =
+			Pattern.compile("(briar://)?([a-z2-7]{" + BASE32_LINK_BYTES + "})");
+
+	/**
+	 * Label for hashing handshake public keys to calculate their identifiers.
+	 */
+	String ID_LABEL = "org.briarproject.bramble/HANDSHAKE_KEY_ID";
+}

bramble-api/src/main/java/org/briarproject/bramble/api/contact/HandshakeManager.java

+package org.briarproject.bramble.api.contact;
+
+import org.briarproject.bramble.api.crypto.SecretKey;
+import org.briarproject.bramble.api.db.DbException;
+import org.briarproject.bramble.api.transport.StreamWriter;
+import org.briarproject.nullsafety.NotNullByDefault;
+
+import java.io.IOException;
+import java.io.InputStream;
+
+@NotNullByDefault
+public interface HandshakeManager {
+
+	/**
+	 * Handshakes with the given pending contact. Returns an ephemeral master
+	 * key authenticated with both parties' handshake key pairs and a flag
+	 * indicating whether the local peer is Alice or Bob.
+	 *
+	 * @param in An incoming stream for the handshake, which must be secured in
+	 * handshake mode
+	 * @param out An outgoing stream for the handshake, which must be secured
+	 * in handshake mode
+	 */
+	HandshakeResult handshake(PendingContactId p, InputStream in,
+			StreamWriter out) throws DbException, IOException;
+
+	class HandshakeResult {
+
+		private final SecretKey masterKey;
+		private final boolean alice;
+
+		public HandshakeResult(SecretKey masterKey, boolean alice) {
+			this.masterKey = masterKey;
+			this.alice = alice;
+		}
+
+		public SecretKey getMasterKey() {
+			return masterKey;
+		}
+
+		public boolean isAlice() {
+			return alice;
+		}
+	}
+}

bramble-api/src/main/java/org/briarproject/bramble/api/contact/PendingContact.java

+package org.briarproject.bramble.api.contact;
+
+import org.briarproject.bramble.api.crypto.PublicKey;
+import org.briarproject.nullsafety.NotNullByDefault;
+
+import javax.annotation.concurrent.Immutable;
+
+@Immutable
+@NotNullByDefault
+public class PendingContact {
+
+	private final PendingContactId id;
+	private final PublicKey publicKey;
+	private final String alias;
+	private final long timestamp;
+
+	public PendingContact(PendingContactId id, PublicKey publicKey,
+			String alias, long timestamp) {
+		this.id = id;
+		this.publicKey = publicKey;
+		this.alias = alias;
+		this.timestamp = timestamp;
+	}
+
+	public PendingContactId getId() {
+		return id;
+	}
+
+	public PublicKey getPublicKey() {
+		return publicKey;
+	}
+
+	public String getAlias() {
+		return alias;
+	}
+
+	public long getTimestamp() {
+		return timestamp;
+	}
+
+	@Override
+	public int hashCode() {
+		return id.hashCode();
+	}
+
+	@Override
+	public boolean equals(Object o) {
+		return o instanceof PendingContact &&
+				id.equals(((PendingContact) o).id);
+	}
+}