diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml
index 20e7a68..c6eaa2d 100644
--- a/app/src/main/AndroidManifest.xml
+++ b/app/src/main/AndroidManifest.xml
@@ -68,6 +68,12 @@
+
+
+
+ abstract fun openInputStream(relativePath: String): InputStream?
+ abstract fun createOutputStream(relativePath: String): OutputStream?
+ abstract fun delete(relativePath: String): Boolean
+ abstract fun lastModifiedMs(relativePath: String): Long
+
+ // ── java.io.File backend (regular /storage/... paths) ────────────────────
+
+ class JavaFile(private val root: File) : LocalAccessor() {
+
+ override fun walkFiles(pair: SyncPair): Map {
+ if (!root.exists()) return emptyMap()
+ val includeExts = pair.includeExtensions.map { it.lowercase().trimStart('.') }.toSet()
+ val excludeExts = pair.excludeExtensions.map { it.lowercase().trimStart('.') }.toSet()
+ val minBytes = pair.minFileSizeKb * 1024L
+ val maxBytes = if (pair.maxFileSizeKb > 0) pair.maxFileSizeKb * 1024L else Long.MAX_VALUE
+
+ return root.walkTopDown()
+ .onEnter { dir -> pair.recursive || dir == root }
+ .filter { it.isFile }
+ .filter { f -> !pair.skipHiddenFiles || !f.name.startsWith('.') }
+ .filter { f -> pair.excludePatterns.none { pat -> f.name.matches(globToRegex(pat)) } }
+ .filter { f ->
+ val ext = f.extension.lowercase()
+ (includeExts.isEmpty() || ext in includeExts) && ext !in excludeExts
+ }
+ .filter { f -> f.length() in minBytes..maxBytes }
+ .associate { f ->
+ val rel = f.relativeTo(root).path
+ rel to LocalFileInfo(rel, f.length(), f.lastModified())
+ }
+ }
+
+ override fun openInputStream(relativePath: String): InputStream =
+ File(root, relativePath).inputStream()
+
+ override fun createOutputStream(relativePath: String): OutputStream {
+ val dest = File(root, relativePath)
+ dest.parentFile?.mkdirs()
+ return dest.outputStream()
+ }
+
+ override fun delete(relativePath: String): Boolean = File(root, relativePath).delete()
+
+ override fun lastModifiedMs(relativePath: String): Long = File(root, relativePath).lastModified()
+ }
+
+ // ── SAF backend (content:// tree URIs from Storage Access Framework) ─────
+
+ class Saf(private val treeUri: Uri, private val resolver: ContentResolver) : LocalAccessor() {
+
+ override fun walkFiles(pair: SyncPair): Map {
+ val rootDocId = DocumentsContract.getTreeDocumentId(treeUri)
+ val childrenUri = DocumentsContract.buildChildDocumentsUriUsingTree(treeUri, rootDocId)
+ return cursorWalk(childrenUri, "", pair)
+ }
+
+ private fun cursorWalk(childrenUri: Uri, base: String, pair: SyncPair): Map {
+ val result = mutableMapOf()
+ val includeExts = pair.includeExtensions.map { it.lowercase().trimStart('.') }.toSet()
+ val excludeExts = pair.excludeExtensions.map { it.lowercase().trimStart('.') }.toSet()
+ val minBytes = pair.minFileSizeKb * 1024L
+ val maxBytes = if (pair.maxFileSizeKb > 0) pair.maxFileSizeKb * 1024L else Long.MAX_VALUE
+
+ val cursor = resolver.query(
+ childrenUri,
+ arrayOf(
+ DocumentsContract.Document.COLUMN_DOCUMENT_ID,
+ DocumentsContract.Document.COLUMN_DISPLAY_NAME,
+ DocumentsContract.Document.COLUMN_MIME_TYPE,
+ DocumentsContract.Document.COLUMN_SIZE,
+ DocumentsContract.Document.COLUMN_LAST_MODIFIED,
+ ),
+ null, null, null,
+ ) ?: return result
+
+ cursor.use {
+ while (it.moveToNext()) {
+ val docId = it.getString(0) ?: continue
+ val name = it.getString(1) ?: continue
+ val mime = it.getString(2) ?: continue
+ val size = it.getLong(3)
+ val modified = it.getLong(4)
+ val rel = if (base.isEmpty()) name else "$base/$name"
+
+ if (mime == DocumentsContract.Document.MIME_TYPE_DIR) {
+ if (pair.recursive) {
+ val subUri = DocumentsContract.buildChildDocumentsUriUsingTree(treeUri, docId)
+ result.putAll(cursorWalk(subUri, rel, pair))
+ }
+ } else {
+ if (pair.skipHiddenFiles && name.startsWith('.')) continue
+ if (pair.excludePatterns.any { pat -> name.matches(globToRegex(pat)) }) continue
+ val ext = name.substringAfterLast('.', "").lowercase()
+ if (includeExts.isNotEmpty() && ext !in includeExts) continue
+ if (ext in excludeExts) continue
+ if (size !in minBytes..maxBytes) continue
+ result[rel] = LocalFileInfo(rel, size, modified)
+ }
+ }
+ }
+ return result
+ }
+
+ override fun openInputStream(relativePath: String): InputStream? {
+ val docUri = findDocUri(relativePath) ?: return null
+ return resolver.openInputStream(docUri)
+ }
+
+ override fun createOutputStream(relativePath: String): OutputStream? {
+ val parts = relativePath.replace('\\', '/').split('/')
+ var currentId = DocumentsContract.getTreeDocumentId(treeUri)
+
+ for (i in 0 until parts.size - 1) {
+ val childrenUri = DocumentsContract.buildChildDocumentsUriUsingTree(treeUri, currentId)
+ currentId = findChildId(childrenUri, parts[i]) ?: run {
+ val parentUri = DocumentsContract.buildDocumentUriUsingTree(treeUri, currentId)
+ val newDir = DocumentsContract.createDocument(
+ resolver, parentUri, DocumentsContract.Document.MIME_TYPE_DIR, parts[i]
+ ) ?: return null
+ DocumentsContract.getDocumentId(newDir)
+ }
+ }
+
+ val fileName = parts.last()
+ val childrenUri = DocumentsContract.buildChildDocumentsUriUsingTree(treeUri, currentId)
+ val parentUri = DocumentsContract.buildDocumentUriUsingTree(treeUri, currentId)
+
+ // Delete existing to allow overwrite
+ findChildId(childrenUri, fileName)?.let { existingId ->
+ DocumentsContract.deleteDocument(
+ resolver,
+ DocumentsContract.buildDocumentUriUsingTree(treeUri, existingId)
+ )
+ }
+
+ val newUri = DocumentsContract.createDocument(
+ resolver, parentUri, "application/octet-stream", fileName
+ ) ?: return null
+ return resolver.openOutputStream(newUri)
+ }
+
+ override fun delete(relativePath: String): Boolean {
+ val docUri = findDocUri(relativePath) ?: return false
+ return DocumentsContract.deleteDocument(resolver, docUri)
+ }
+
+ override fun lastModifiedMs(relativePath: String): Long {
+ val docUri = findDocUri(relativePath) ?: return 0L
+ val cursor = resolver.query(
+ docUri,
+ arrayOf(DocumentsContract.Document.COLUMN_LAST_MODIFIED),
+ null, null, null,
+ ) ?: return 0L
+ return cursor.use { if (it.moveToFirst()) it.getLong(0) else 0L }
+ }
+
+ private fun findDocUri(relativePath: String): Uri? {
+ var currentId = DocumentsContract.getTreeDocumentId(treeUri)
+ for (part in relativePath.replace('\\', '/').split('/')) {
+ val childrenUri = DocumentsContract.buildChildDocumentsUriUsingTree(treeUri, currentId)
+ currentId = findChildId(childrenUri, part) ?: return null
+ }
+ return DocumentsContract.buildDocumentUriUsingTree(treeUri, currentId)
+ }
+
+ private fun findChildId(childrenUri: Uri, name: String): String? {
+ val cursor = resolver.query(
+ childrenUri,
+ arrayOf(
+ DocumentsContract.Document.COLUMN_DOCUMENT_ID,
+ DocumentsContract.Document.COLUMN_DISPLAY_NAME,
+ ),
+ null, null, null,
+ ) ?: return null
+ return cursor.use {
+ while (it.moveToNext()) {
+ if (it.getString(1) == name) return@use it.getString(0)
+ }
+ null
+ }
+ }
+ }
+}
+
+internal fun globToRegex(pat: String): Regex =
+ Regex(pat.replace(".", "\\.").replace("*", ".*").replace("?", "."), RegexOption.IGNORE_CASE)
diff --git a/app/src/main/kotlin/com/syncflow/domain/sync/SyncEngine.kt b/app/src/main/kotlin/com/syncflow/domain/sync/SyncEngine.kt
index a26383b..94601da 100644
--- a/app/src/main/kotlin/com/syncflow/domain/sync/SyncEngine.kt
+++ b/app/src/main/kotlin/com/syncflow/domain/sync/SyncEngine.kt
@@ -1,12 +1,13 @@
package com.syncflow.domain.sync
+import android.content.Context
+import android.net.Uri
import com.syncflow.data.db.SyncConflictDao
import com.syncflow.data.db.SyncEventDao
import com.syncflow.data.db.SyncFileStateDao
import com.syncflow.data.db.SyncPairDao
import com.syncflow.data.db.entities.SyncConflictEntity
import com.syncflow.data.db.entities.SyncEventEntity
-import com.syncflow.data.db.entities.SyncFileStateEntity
import com.syncflow.data.providers.CloudProvider
import com.syncflow.domain.model.ConflictStrategy
import com.syncflow.domain.model.DeleteBehavior
@@ -15,12 +16,12 @@ import com.syncflow.domain.model.SyncDirection
import com.syncflow.domain.model.SyncEventType
import com.syncflow.domain.model.SyncPair
import com.syncflow.domain.model.SyncStatus
+import dagger.hilt.android.qualifiers.ApplicationContext
import kotlinx.coroutines.*
import kotlinx.coroutines.sync.Semaphore
import kotlinx.coroutines.sync.withPermit
import timber.log.Timber
import java.io.File
-import java.security.MessageDigest
import java.time.Instant
import javax.inject.Inject
@@ -29,6 +30,7 @@ class SyncEngine @Inject constructor(
private val fileStateDao: SyncFileStateDao,
private val conflictDao: SyncConflictDao,
private val eventDao: SyncEventDao,
+ @ApplicationContext private val context: Context,
) {
suspend fun sync(pair: SyncPair, provider: CloudProvider): SyncResult {
syncPairDao.updateStatus(pair.id, SyncStatus.SYNCING)
@@ -53,20 +55,26 @@ class SyncEngine @Inject constructor(
}
}
+ private fun makeAccessor(localPath: String): LocalAccessor =
+ if (localPath.startsWith("content://"))
+ LocalAccessor.Saf(Uri.parse(localPath), context.contentResolver)
+ else
+ LocalAccessor.JavaFile(File(localPath))
+
private suspend fun performSync(pair: SyncPair, provider: CloudProvider): SyncResult {
- val localRoot = File(pair.localPath)
+ val accessor = makeAccessor(pair.localPath)
val knownStates = fileStateDao.getForPair(pair.id).associateBy { it.relativePath }
- val remoteFiles = provider.listFiles(pair.remotePath).getOrThrow().associateBy { it.path.removePrefix(pair.remotePath).trimStart('/') }
- val localFiles = localRoot.walkFiles(pair)
+ val remoteFiles = provider.listFiles(pair.remotePath).getOrThrow()
+ .associateBy { it.path.removePrefix(pair.remotePath).trimStart('/') }
+ val localFiles = accessor.walkFiles(pair)
var uploaded = 0; var downloaded = 0; var deleted = 0; var skipped = 0; var failed = 0; var conflicts = 0
var bytesTransferred = 0L
- val newStates = mutableListOf()
+ val newStates = mutableListOf()
val allPaths = (localFiles.keys + remoteFiles.keys + knownStates.keys).toSet()
-
- // Fan out with bounded parallelism
val semaphore = Semaphore(4)
+
coroutineScope {
allPaths.map { rel ->
async {
@@ -78,12 +86,11 @@ class SyncEngine @Inject constructor(
when (decision) {
SyncDecision.UPLOAD -> {
- val file = File(localRoot, rel)
val bytes = runCatching {
- file.inputStream().use { stream ->
- provider.uploadFile(stream, "${pair.remotePath}/$rel", file.length()) { }
+ accessor.openInputStream(rel)?.use { stream ->
+ provider.uploadFile(stream, "${pair.remotePath}/$rel", local!!.sizeBytes) { }
}
- file.length()
+ local!!.sizeBytes
}.getOrElse { e ->
Timber.e(e, "Upload failed: $rel")
failed++
@@ -92,13 +99,12 @@ class SyncEngine @Inject constructor(
}
uploaded++
bytesTransferred += bytes
- newStates += buildState(pair.id, rel, file, remote)
+ newStates += buildState(pair.id, rel, local!!, remote)
logEvent(pair.id, SyncEventType.FILE_UPLOADED, rel, null, bytes)
}
SyncDecision.DOWNLOAD -> {
- val dest = File(localRoot, rel).also { it.parentFile?.mkdirs() }
val bytes = runCatching {
- dest.outputStream().use { stream ->
+ accessor.createOutputStream(rel)?.use { stream ->
provider.downloadFile("${pair.remotePath}/$rel", stream) { }
}
remote!!.sizeBytes
@@ -110,11 +116,11 @@ class SyncEngine @Inject constructor(
}
downloaded++
bytesTransferred += bytes
- newStates += buildState(pair.id, rel, dest, remote)
+ newStates += buildState(pair.id, rel, null, remote)
logEvent(pair.id, SyncEventType.FILE_DOWNLOADED, rel, null, bytes)
}
SyncDecision.DELETE_LOCAL -> {
- File(localRoot, rel).delete()
+ accessor.delete(rel)
fileStateDao.delete(pair.id, rel)
deleted++
logEvent(pair.id, SyncEventType.FILE_DELETED, rel, "local", 0)
@@ -130,8 +136,8 @@ class SyncEngine @Inject constructor(
conflictDao.insert(SyncConflictEntity(
syncPairId = pair.id,
relativePath = rel,
- localModifiedAt = local?.lastModified()?.let { Instant.ofEpochMilli(it) } ?: Instant.EPOCH,
- localSizeBytes = local?.length() ?: 0L,
+ localModifiedAt = local?.lastModifiedMs?.let { Instant.ofEpochMilli(it) } ?: Instant.EPOCH,
+ localSizeBytes = local?.sizeBytes ?: 0L,
remoteModifiedAt = remote?.modifiedAt ?: Instant.EPOCH,
remoteSizeBytes = remote?.sizeBytes ?: 0L,
resolution = null,
@@ -154,26 +160,24 @@ class SyncEngine @Inject constructor(
direction: SyncDirection,
conflictStrategy: ConflictStrategy,
deleteBehavior: DeleteBehavior,
- local: File?,
+ local: LocalFileInfo?,
remote: RemoteFile?,
- known: SyncFileStateEntity?,
+ known: com.syncflow.data.db.entities.SyncFileStateEntity?,
): SyncDecision {
- val localExists = local?.exists() == true
+ val localExists = local != null
val remoteExists = remote != null
- val localChanged = known == null || (localExists && local!!.lastModified() != known.localModifiedAt?.toEpochMilli())
+ val localChanged = known == null || (localExists && local!!.lastModifiedMs != known.localModifiedAt?.toEpochMilli())
val remoteChanged = known == null || (remoteExists && remote!!.etag != known.remoteEtag && remote.modifiedAt != known.remoteModifiedAt)
return when {
!localExists && !remoteExists -> SyncDecision.SKIP
- // File only exists locally
localExists && !remoteExists -> when {
known == null -> when (direction) {
SyncDirection.UPLOAD_ONLY, SyncDirection.TWO_WAY -> SyncDecision.UPLOAD
else -> SyncDecision.SKIP
}
- // Remote was deleted — respect deleteBehavior
else -> when {
deleteBehavior == DeleteBehavior.KEEP -> SyncDecision.SKIP
direction == SyncDirection.DOWNLOAD_ONLY || direction == SyncDirection.TWO_WAY -> SyncDecision.DELETE_LOCAL
@@ -181,13 +185,11 @@ class SyncEngine @Inject constructor(
}
}
- // File only exists remotely
!localExists && remoteExists -> when {
known == null -> when (direction) {
SyncDirection.DOWNLOAD_ONLY, SyncDirection.TWO_WAY -> SyncDecision.DOWNLOAD
else -> SyncDecision.SKIP
}
- // Local was deleted — respect deleteBehavior
else -> when {
deleteBehavior == DeleteBehavior.KEEP -> SyncDecision.SKIP
direction == SyncDirection.UPLOAD_ONLY || direction == SyncDirection.TWO_WAY -> SyncDecision.DELETE_REMOTE
@@ -195,16 +197,15 @@ class SyncEngine @Inject constructor(
}
}
- // Both changed — conflict
localChanged && remoteChanged -> when (direction) {
SyncDirection.UPLOAD_ONLY -> SyncDecision.UPLOAD
SyncDirection.DOWNLOAD_ONLY -> SyncDecision.DOWNLOAD
SyncDirection.TWO_WAY -> when (conflictStrategy) {
ConflictStrategy.KEEP_LOCAL -> SyncDecision.UPLOAD
ConflictStrategy.KEEP_REMOTE -> SyncDecision.DOWNLOAD
- ConflictStrategy.KEEP_NEWEST -> if ((local?.lastModified() ?: 0L) >= (remote?.modifiedAt?.toEpochMilli() ?: 0L)) SyncDecision.UPLOAD else SyncDecision.DOWNLOAD
- ConflictStrategy.KEEP_LARGEST -> if ((local?.length() ?: 0L) >= (remote?.sizeBytes ?: 0L)) SyncDecision.UPLOAD else SyncDecision.DOWNLOAD
- ConflictStrategy.KEEP_BOTH -> SyncDecision.CONFLICT // engine keeps both via rename
+ ConflictStrategy.KEEP_NEWEST -> if ((local?.lastModifiedMs ?: 0L) >= (remote?.modifiedAt?.toEpochMilli() ?: 0L)) SyncDecision.UPLOAD else SyncDecision.DOWNLOAD
+ ConflictStrategy.KEEP_LARGEST -> if ((local?.sizeBytes ?: 0L) >= (remote?.sizeBytes ?: 0L)) SyncDecision.UPLOAD else SyncDecision.DOWNLOAD
+ ConflictStrategy.KEEP_BOTH -> SyncDecision.CONFLICT
ConflictStrategy.ASK -> SyncDecision.CONFLICT
}
}
@@ -221,11 +222,16 @@ class SyncEngine @Inject constructor(
}
}
- private fun buildState(pairId: Long, rel: String, local: File, remote: RemoteFile?) = SyncFileStateEntity(
+ private fun buildState(
+ pairId: Long,
+ rel: String,
+ local: LocalFileInfo?,
+ remote: RemoteFile?,
+ ) = com.syncflow.data.db.entities.SyncFileStateEntity(
syncPairId = pairId,
relativePath = rel,
- localModifiedAt = if (local.exists()) Instant.ofEpochMilli(local.lastModified()) else null,
- localSizeBytes = local.length(),
+ localModifiedAt = local?.lastModifiedMs?.let { Instant.ofEpochMilli(it) },
+ localSizeBytes = local?.sizeBytes ?: 0L,
localHash = null,
remoteModifiedAt = remote?.modifiedAt,
remoteSizeBytes = remote?.sizeBytes ?: 0L,
@@ -237,31 +243,6 @@ class SyncEngine @Inject constructor(
private suspend fun logEvent(pairId: Long, type: SyncEventType, file: String?, msg: String?, bytes: Long) {
eventDao.insert(SyncEventEntity(syncPairId = pairId, timestamp = Instant.now(), eventType = type, filePath = file, message = msg, bytesTransferred = bytes))
}
-
- private fun File.walkFiles(pair: SyncPair): Map {
- if (!exists()) return emptyMap()
- val includeExts = pair.includeExtensions.map { it.lowercase().trimStart('.') }.toSet()
- val excludeExts = pair.excludeExtensions.map { it.lowercase().trimStart('.') }.toSet()
- val minBytes = pair.minFileSizeKb * 1024
- val maxBytes = if (pair.maxFileSizeKb > 0) pair.maxFileSizeKb * 1024 else Long.MAX_VALUE
-
- return walkTopDown()
- .onEnter { dir ->
- pair.recursive || dir == this
- }
- .filter { it.isFile }
- .filter { f -> !pair.skipHiddenFiles || !f.name.startsWith('.') }
- .filter { f -> pair.excludePatterns.none { pat -> f.name.matches(pat.toGlob()) } }
- .filter { f ->
- val ext = f.extension.lowercase()
- (includeExts.isEmpty() || ext in includeExts) && ext !in excludeExts
- }
- .filter { f -> f.length() >= minBytes && f.length() <= maxBytes }
- .associate { f -> f.relativeTo(this).path to f }
- }
-
- private fun String.toGlob(): Regex =
- Regex(replace(".", "\\.").replace("*", ".*").replace("?", "."), RegexOption.IGNORE_CASE)
}
enum class SyncDecision { UPLOAD, DOWNLOAD, DELETE_LOCAL, DELETE_REMOTE, CONFLICT, SKIP }
diff --git a/app/src/main/kotlin/com/syncflow/worker/SyncWorker.kt b/app/src/main/kotlin/com/syncflow/worker/SyncWorker.kt
index e96a6a4..5113f8b 100644
--- a/app/src/main/kotlin/com/syncflow/worker/SyncWorker.kt
+++ b/app/src/main/kotlin/com/syncflow/worker/SyncWorker.kt
@@ -3,6 +3,8 @@ package com.syncflow.worker
import android.app.NotificationChannel
import android.app.NotificationManager
import android.content.Context
+import android.content.pm.ServiceInfo
+import android.os.Build
import androidx.core.app.NotificationCompat
import androidx.hilt.work.HiltWorker
import androidx.work.*
@@ -59,7 +61,11 @@ class SyncWorker @AssistedInject constructor(
.setSmallIcon(R.drawable.ic_sync)
.setOngoing(true)
.build()
- return ForegroundInfo(NOTIFICATION_ID, notification)
+ return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+ ForegroundInfo(NOTIFICATION_ID, notification, ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC)
+ } else {
+ ForegroundInfo(NOTIFICATION_ID, notification)
+ }
}
companion object {
diff --git a/version.properties b/version.properties
index 478eaea..65b5a9e 100644
--- a/version.properties
+++ b/version.properties
@@ -1,2 +1,2 @@
-VERSION_NAME=1.0.0
-VERSION_CODE=1
+VERSION_NAME=1.0.1
+VERSION_CODE=2