Add folder upload support

data/build.gradle

@@ -102,7 +102,7 @@ android {
 }
 
 greendao {
-	schemaVersion 13
+	schemaVersion 14
 }
 
 configurations.all {

data/src/androidTest/java/org/cryptomator/data/db/UpgradeDatabaseTest.kt

@@ -56,6 +56,7 @@ class UpgradeDatabaseTest {
 		Upgrade10To11().applyTo(db, 10)
 		Upgrade11To12(sharedPreferencesHandler).applyTo(db, 11)
 		Upgrade12To13(context).applyTo(db, 12)
+		Upgrade13To14().applyTo(db, 13)
 
 		CloudEntityDao(DaoConfig(db, CloudEntityDao::class.java)).loadAll()
 		VaultEntityDao(DaoConfig(db, VaultEntityDao::class.java)).loadAll()
@@ -915,6 +916,97 @@ class UpgradeDatabaseTest {
 		}
 	}
 
+	@Test
+	fun upgrade13To14() {
+		Upgrade0To1().applyTo(db, 0)
+		Upgrade1To2().applyTo(db, 1)
+		Upgrade2To3(context).applyTo(db, 2)
+		Upgrade3To4().applyTo(db, 3)
+		Upgrade4To5().applyTo(db, 4)
+		Upgrade5To6().applyTo(db, 5)
+		Upgrade6To7().applyTo(db, 6)
+		Upgrade7To8().applyTo(db, 7)
+		Upgrade8To9(sharedPreferencesHandler).applyTo(db, 8)
+		Upgrade9To10(sharedPreferencesHandler).applyTo(db, 9)
+		Upgrade10To11().applyTo(db, 10)
+		Upgrade11To12(sharedPreferencesHandler).applyTo(db, 11)
+		Upgrade12To13(context).applyTo(db, 12)
+
+		Upgrade13To14().applyTo(db, 13)
+
+		// Insert a checkpoint row
+		Sql.insertInto("UPLOAD_CHECKPOINT_ENTITY") //
+			.integer("_id", 1) //
+			.integer("VAULT_ID", 42) //
+			.text("TYPE", "folder") //
+			.text("TARGET_FOLDER_PATH", "/Documents") //
+			.text("SOURCE_FOLDER_URI", "content://tree/uri") //
+			.text("SOURCE_FOLDER_NAME", "Photos") //
+			.text("PENDING_FILE_URIS", null) //
+			.text("COMPLETED_FILES", "[\"file1.txt\"]") //
+			.integer("TOTAL_FILE_COUNT", 5) //
+			.integer("TIMESTAMP", 1700000000) //
+			.executeOn(db)
+
+		Sql.query("UPLOAD_CHECKPOINT_ENTITY").where("VAULT_ID", Sql.eq(42)).executeOn(db).use {
+			it.moveToFirst()
+			Assert.assertThat(it.getInt(it.getColumnIndex("_id")), CoreMatchers.`is`(1))
+			Assert.assertThat(it.getInt(it.getColumnIndex("VAULT_ID")), CoreMatchers.`is`(42))
+			Assert.assertThat(it.getString(it.getColumnIndex("TYPE")), CoreMatchers.`is`("folder"))
+			Assert.assertThat(it.getString(it.getColumnIndex("TARGET_FOLDER_PATH")), CoreMatchers.`is`("/Documents"))
+			Assert.assertThat(it.getString(it.getColumnIndex("SOURCE_FOLDER_URI")), CoreMatchers.`is`("content://tree/uri"))
+			Assert.assertThat(it.getString(it.getColumnIndex("SOURCE_FOLDER_NAME")), CoreMatchers.`is`("Photos"))
+			Assert.assertThat(it.getString(it.getColumnIndex("COMPLETED_FILES")), CoreMatchers.`is`("[\"file1.txt\"]"))
+			Assert.assertThat(it.getInt(it.getColumnIndex("TOTAL_FILE_COUNT")), CoreMatchers.`is`(5))
+			Assert.assertThat(it.getLong(it.getColumnIndex("TIMESTAMP")), CoreMatchers.`is`(1700000000L))
+		}
+	}
+
+	@Test
+	fun upgrade13To14UniqueVaultIdConstraint() {
+		Upgrade0To1().applyTo(db, 0)
+		Upgrade1To2().applyTo(db, 1)
+		Upgrade2To3(context).applyTo(db, 2)
+		Upgrade3To4().applyTo(db, 3)
+		Upgrade4To5().applyTo(db, 4)
+		Upgrade5To6().applyTo(db, 5)
+		Upgrade6To7().applyTo(db, 6)
+		Upgrade7To8().applyTo(db, 7)
+		Upgrade8To9(sharedPreferencesHandler).applyTo(db, 8)
+		Upgrade9To10(sharedPreferencesHandler).applyTo(db, 9)
+		Upgrade10To11().applyTo(db, 10)
+		Upgrade11To12(sharedPreferencesHandler).applyTo(db, 11)
+		Upgrade12To13(context).applyTo(db, 12)
+
+		Upgrade13To14().applyTo(db, 13)
+
+		Sql.insertInto("UPLOAD_CHECKPOINT_ENTITY") //
+			.integer("_id", 1) //
+			.integer("VAULT_ID", 42) //
+			.text("TYPE", "files") //
+			.text("TARGET_FOLDER_PATH", "/path") //
+			.text("COMPLETED_FILES", "[]") //
+			.integer("TOTAL_FILE_COUNT", 1) //
+			.integer("TIMESTAMP", 1000) //
+			.executeOn(db)
+
+		// Inserting a second row with the same VAULT_ID should fail due to unique index
+		try {
+			Sql.insertInto("UPLOAD_CHECKPOINT_ENTITY") //
+				.integer("_id", 2) //
+				.integer("VAULT_ID", 42) //
+				.text("TYPE", "folder") //
+				.text("TARGET_FOLDER_PATH", "/other") //
+				.text("COMPLETED_FILES", "[]") //
+				.integer("TOTAL_FILE_COUNT", 2) //
+				.integer("TIMESTAMP", 2000) //
+				.executeOn(db)
+			Assert.fail("Expected constraint violation for duplicate VAULT_ID")
+		} catch (e: android.database.sqlite.SQLiteConstraintException) {
+			// Expected: unique constraint violation on VAULT_ID
+		}
+	}
+
 	@Test
 	fun upgrade12To13Webdav() {
 		Upgrade0To1().applyTo(db, 0)

data/src/main/java/org/cryptomator/data/db/DatabaseUpgrades.java

@@ -31,7 +31,8 @@ public DatabaseUpgrades( //
 			Upgrade9To10 upgrade9To10, //
 			Upgrade10To11 upgrade10To11, //
 			Upgrade11To12 upgrade11To12, //
-			Upgrade12To13 upgrade12To13
+			Upgrade12To13 upgrade12To13, //
+			Upgrade13To14 upgrade13To14
 	) {
 
 		availableUpgrades = defineUpgrades( //
@@ -47,7 +48,8 @@ public DatabaseUpgrades( //
 				upgrade9To10, //
 				upgrade10To11, //
 				upgrade11To12, //
-				upgrade12To13);
+				upgrade12To13, //
+				upgrade13To14);
 	}
 
 	private Map<Integer, List<DatabaseUpgrade>> defineUpgrades(DatabaseUpgrade... upgrades) {

data/src/main/java/org/cryptomator/data/db/Upgrade13To14.kt

@@ -0,0 +1,39 @@
+package org.cryptomator.data.db
+
+import org.greenrobot.greendao.database.Database
+import javax.inject.Inject
+import javax.inject.Singleton
+
+@Singleton
+internal class Upgrade13To14 @Inject constructor() : DatabaseUpgrade(13, 14) {
+
+	override fun internalApplyTo(db: Database, origin: Int) {
+		db.beginTransaction()
+		try {
+			createUploadCheckpointTable(db)
+			db.setTransactionSuccessful()
+		} finally {
+			db.endTransaction()
+		}
+	}
+
+	private fun createUploadCheckpointTable(db: Database) {
+		Sql.createTable("UPLOAD_CHECKPOINT_ENTITY") //
+			.id() //
+			.requiredInt("VAULT_ID") //
+			.requiredText("TYPE") //
+			.requiredText("TARGET_FOLDER_PATH") //
+			.optionalText("SOURCE_FOLDER_URI") //
+			.optionalText("SOURCE_FOLDER_NAME") //
+			.optionalText("PENDING_FILE_URIS") //
+			.requiredText("COMPLETED_FILES") //
+			.requiredInt("TOTAL_FILE_COUNT") //
+			.requiredInt("TIMESTAMP") //
+			.executeOn(db)
+
+		Sql.createUniqueIndex("IDX_UPLOAD_CHECKPOINT_ENTITY_VAULT_ID") //
+			.on("UPLOAD_CHECKPOINT_ENTITY") //
+			.asc("VAULT_ID") //
+			.executeOn(db)
+	}
+}

data/src/main/java/org/cryptomator/data/db/UploadCheckpointDao.java

@@ -0,0 +1,81 @@
+package org.cryptomator.data.db;
+
+import android.content.ContentValues;
+import android.database.Cursor;
+import android.database.sqlite.SQLiteDatabase;
+
+import org.cryptomator.data.db.entities.UploadCheckpointEntity;
+
+import javax.inject.Inject;
+import javax.inject.Singleton;
+
+@Singleton
+public class UploadCheckpointDao {
+
+	private static final String TABLE_NAME = "UPLOAD_CHECKPOINT_ENTITY";
+
+	private final DatabaseFactory databaseFactory;
+
+	@Inject
+	public UploadCheckpointDao(DatabaseFactory databaseFactory) {
+		this.databaseFactory = databaseFactory;
+	}
+
+	private SQLiteDatabase getDb() {
+		return databaseFactory.getWritableDatabase();
+	}
+
+	public long insertOrReplace(UploadCheckpointEntity entity) {
+		ContentValues values = toContentValues(entity);
+		return getDb().insertWithOnConflict(TABLE_NAME, null, values, SQLiteDatabase.CONFLICT_REPLACE);
+	}
+
+	public UploadCheckpointEntity findByVaultId(long vaultId) {
+		try (Cursor cursor = getDb().query(TABLE_NAME, null, "VAULT_ID = ?",
+				new String[]{String.valueOf(vaultId)}, null, null, null)) {
+			if (cursor.moveToFirst()) {
+				return fromCursor(cursor);
+			}
+			return null;
+		}
+	}
+
+	public void deleteByVaultId(long vaultId) {
+		getDb().delete(TABLE_NAME, "VAULT_ID = ?", new String[]{String.valueOf(vaultId)});
+	}
+
+	public void updateCompletedFiles(long vaultId, String completedFilesJson) {
+		ContentValues values = new ContentValues();
+		values.put("COMPLETED_FILES", completedFilesJson);
+		getDb().update(TABLE_NAME, values, "VAULT_ID = ?", new String[]{String.valueOf(vaultId)});
+	}
+
+	private ContentValues toContentValues(UploadCheckpointEntity entity) {
+		ContentValues values = new ContentValues();
+		values.put("VAULT_ID", entity.getVaultId());
+		values.put("TYPE", entity.getType());
+		values.put("TARGET_FOLDER_PATH", entity.getTargetFolderPath());
+		values.put("SOURCE_FOLDER_URI", entity.getSourceFolderUri());
+		values.put("SOURCE_FOLDER_NAME", entity.getSourceFolderName());
+		values.put("PENDING_FILE_URIS", entity.getPendingFileUris());
+		values.put("COMPLETED_FILES", entity.getCompletedFiles());
+		values.put("TOTAL_FILE_COUNT", entity.getTotalFileCount());
+		values.put("TIMESTAMP", entity.getTimestamp());
+		return values;
+	}
+
+	private UploadCheckpointEntity fromCursor(Cursor cursor) {
+		UploadCheckpointEntity entity = new UploadCheckpointEntity();
+		entity.setId(cursor.getLong(cursor.getColumnIndexOrThrow("_id")));
+		entity.setVaultId(cursor.getLong(cursor.getColumnIndexOrThrow("VAULT_ID")));
+		entity.setType(cursor.getString(cursor.getColumnIndexOrThrow("TYPE")));
+		entity.setTargetFolderPath(cursor.getString(cursor.getColumnIndexOrThrow("TARGET_FOLDER_PATH")));
+		entity.setSourceFolderUri(cursor.getString(cursor.getColumnIndexOrThrow("SOURCE_FOLDER_URI")));
+		entity.setSourceFolderName(cursor.getString(cursor.getColumnIndexOrThrow("SOURCE_FOLDER_NAME")));
+		entity.setPendingFileUris(cursor.getString(cursor.getColumnIndexOrThrow("PENDING_FILE_URIS")));
+		entity.setCompletedFiles(cursor.getString(cursor.getColumnIndexOrThrow("COMPLETED_FILES")));
+		entity.setTotalFileCount(cursor.getInt(cursor.getColumnIndexOrThrow("TOTAL_FILE_COUNT")));
+		entity.setTimestamp(cursor.getLong(cursor.getColumnIndexOrThrow("TIMESTAMP")));
+		return entity;
+	}
+}

data/src/main/java/org/cryptomator/data/db/entities/UploadCheckpointEntity.java

@@ -0,0 +1,140 @@
+package org.cryptomator.data.db.entities;
+
+import org.greenrobot.greendao.annotation.Entity;
+import org.greenrobot.greendao.annotation.Id;
+import org.greenrobot.greendao.annotation.Index;
+import org.greenrobot.greendao.annotation.NotNull;
+import org.greenrobot.greendao.annotation.Generated;
+
+@Entity(indexes = {@Index(value = "vaultId", unique = true)})
+public class UploadCheckpointEntity extends DatabaseEntity {
+
+	@Id
+	private Long id;
+
+	@NotNull
+	private Long vaultId;
+
+	@NotNull
+	private String type;
+
+	@NotNull
+	private String targetFolderPath;
+
+	private String sourceFolderUri;
+
+	private String sourceFolderName;
+
+	private String pendingFileUris;
+
+	@NotNull
+	private String completedFiles;
+
+	@NotNull
+	private int totalFileCount;
+
+	@NotNull
+	private long timestamp;
+
+	@Generated(hash = 482695414)
+	public UploadCheckpointEntity(Long id, @NotNull Long vaultId,
+			@NotNull String type, @NotNull String targetFolderPath,
+			String sourceFolderUri, String sourceFolderName, String pendingFileUris,
+			@NotNull String completedFiles, int totalFileCount, long timestamp) {
+		this.id = id;
+		this.vaultId = vaultId;
+		this.type = type;
+		this.targetFolderPath = targetFolderPath;
+		this.sourceFolderUri = sourceFolderUri;
+		this.sourceFolderName = sourceFolderName;
+		this.pendingFileUris = pendingFileUris;
+		this.completedFiles = completedFiles;
+		this.totalFileCount = totalFileCount;
+		this.timestamp = timestamp;
+	}
+
+	@Generated(hash = 1737881290)
+	public UploadCheckpointEntity() {
+	}
+
+	@Override
+	public Long getId() {
+		return this.id;
+	}
+
+	public void setId(Long id) {
+		this.id = id;
+	}
+
+	public Long getVaultId() {
+		return this.vaultId;
+	}
+
+	public void setVaultId(Long vaultId) {
+		this.vaultId = vaultId;
+	}
+
+	public String getType() {
+		return this.type;
+	}
+
+	public void setType(String type) {
+		this.type = type;
+	}
+
+	public String getTargetFolderPath() {
+		return this.targetFolderPath;
+	}
+
+	public void setTargetFolderPath(String targetFolderPath) {
+		this.targetFolderPath = targetFolderPath;
+	}
+
+	public String getSourceFolderUri() {
+		return this.sourceFolderUri;
+	}
+
+	public void setSourceFolderUri(String sourceFolderUri) {
+		this.sourceFolderUri = sourceFolderUri;
+	}
+
+	public String getSourceFolderName() {
+		return this.sourceFolderName;
+	}
+
+	public void setSourceFolderName(String sourceFolderName) {
+		this.sourceFolderName = sourceFolderName;
+	}
+
+	public String getPendingFileUris() {
+		return this.pendingFileUris;
+	}
+
+	public void setPendingFileUris(String pendingFileUris) {
+		this.pendingFileUris = pendingFileUris;
+	}
+
+	public String getCompletedFiles() {
+		return this.completedFiles;
+	}
+
+	public void setCompletedFiles(String completedFiles) {
+		this.completedFiles = completedFiles;
+	}
+
+	public int getTotalFileCount() {
+		return this.totalFileCount;
+	}
+
+	public void setTotalFileCount(int totalFileCount) {
+		this.totalFileCount = totalFileCount;
+	}
+
+	public long getTimestamp() {
+		return this.timestamp;
+	}
+
+	public void setTimestamp(long timestamp) {
+		this.timestamp = timestamp;
+	}
+}