发布 0.4.7 双向并发传输封版
This commit is contained in:
@@ -12,8 +12,8 @@ android {
|
||||
applicationId = "com.qft.optical"
|
||||
minSdk = 24
|
||||
targetSdk = 35
|
||||
versionCode = 18
|
||||
versionName = "0.4.6"
|
||||
versionCode = 19
|
||||
versionName = "0.4.7"
|
||||
|
||||
testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
|
||||
}
|
||||
|
||||
@@ -13,9 +13,13 @@ import java.io.File
|
||||
import java.io.FileInputStream
|
||||
import java.io.FileOutputStream
|
||||
import java.io.OutputStream
|
||||
import java.io.RandomAccessFile
|
||||
import java.net.HttpURLConnection
|
||||
import java.net.URL
|
||||
import java.nio.ByteBuffer
|
||||
import java.security.MessageDigest
|
||||
import java.util.concurrent.Executors
|
||||
import java.util.concurrent.atomic.AtomicInteger
|
||||
|
||||
data class DownloadedFile(val name: String, val size: Long, val uri: Uri?)
|
||||
|
||||
@@ -24,13 +28,104 @@ data class DownloadedFile(val name: String, val size: Long, val uri: Uri?)
|
||||
object DownloadClient {
|
||||
private const val TAG = "QftDownload"
|
||||
private const val BUFFER_SIZE = 1024 * 1024
|
||||
private const val RANGE_WORKERS = 8
|
||||
private const val RANGE_ATTEMPTS = 5
|
||||
private const val ATTEMPTS = 5
|
||||
private const val MIN_RANGE_CHUNK = 64L * 1024L
|
||||
private const val MAX_RANGE_CHUNK = 16L * 1024L * 1024L
|
||||
/** 整份重下的轮数。仅在 SHA-256 不匹配(缓存已损坏)时才会用到第二轮。 */
|
||||
private const val VERIFY_ROUNDS = 2
|
||||
|
||||
/** 落盘阶段的失败与「下载失败」是两回事,用独立异常类型区分。 */
|
||||
class SaveFailure(message: String, cause: Throwable?) : Exception(message, cause)
|
||||
|
||||
/** Persistent received-range map. The data file is preallocated, so its
|
||||
* length is not used as a completion signal; only an atomically replaced
|
||||
* map entry marks a range safe to resume. */
|
||||
private class ChunkLedger private constructor(
|
||||
private val partial: File,
|
||||
private val map: File,
|
||||
private val size: Long,
|
||||
val chunkSize: Long,
|
||||
val totalChunks: Int,
|
||||
private val completed: BooleanArray,
|
||||
) {
|
||||
private val lock = Any()
|
||||
|
||||
fun isComplete(index: Int): Boolean = synchronized(lock) { completed[index] }
|
||||
|
||||
fun allComplete(): Boolean = synchronized(lock) { completed.all { it } }
|
||||
|
||||
fun bytesComplete(): Long = synchronized(lock) {
|
||||
completed.indices.sumOf { index -> if (completed[index]) chunkLength(index) else 0L }
|
||||
}
|
||||
|
||||
fun chunkOffset(index: Int): Long = index.toLong() * chunkSize
|
||||
|
||||
fun chunkLength(index: Int): Long = minOf(chunkSize, size - chunkOffset(index))
|
||||
|
||||
fun markComplete(index: Int) = synchronized(lock) {
|
||||
if (!completed[index]) {
|
||||
completed[index] = true
|
||||
persistLocked()
|
||||
}
|
||||
}
|
||||
|
||||
fun discard() = synchronized(lock) {
|
||||
partial.delete()
|
||||
map.delete()
|
||||
File("${map.path}.tmp").delete()
|
||||
}
|
||||
|
||||
private fun persistLocked() {
|
||||
val temp = File("${map.path}.tmp")
|
||||
temp.bufferedWriter().use { writer ->
|
||||
writer.appendLine("$size:$chunkSize:$totalChunks")
|
||||
writer.write(buildString(totalChunks) {
|
||||
completed.forEach { append(if (it) '1' else '0') }
|
||||
})
|
||||
}
|
||||
if (map.exists()) map.delete()
|
||||
if (!temp.renameTo(map)) {
|
||||
temp.copyTo(map, overwrite = true)
|
||||
temp.delete()
|
||||
}
|
||||
}
|
||||
|
||||
companion object {
|
||||
fun open(partial: File, size: Long, chunkSize: Long): ChunkLedger {
|
||||
val totalLong = if (size == 0L) 0L else (size + chunkSize - 1L) / chunkSize
|
||||
require(totalLong <= Int.MAX_VALUE) { "文件分块数过大" }
|
||||
val total = totalLong.toInt()
|
||||
val map = File("${partial.path}.map")
|
||||
val restored = runCatching {
|
||||
val pieces = map.readText().split('\n', limit = 2)
|
||||
val header = pieces.firstOrNull()?.split(':') ?: emptyList()
|
||||
val bits = pieces.getOrNull(1).orEmpty()
|
||||
if (
|
||||
partial.length() == size && header.size == 3 &&
|
||||
header[0].toLong() == size && header[1].toLong() == chunkSize &&
|
||||
header[2].toInt() == total && bits.length >= total
|
||||
) {
|
||||
BooleanArray(total) { bits[it] == '1' }
|
||||
} else {
|
||||
null
|
||||
}
|
||||
}.getOrNull()
|
||||
val ledger = ChunkLedger(partial, map, size, chunkSize, total, restored ?: BooleanArray(total))
|
||||
if (restored == null) {
|
||||
partial.parentFile?.let { if (!it.exists()) it.mkdirs() }
|
||||
RandomAccessFile(partial, "rw").use { file ->
|
||||
file.setLength(0L)
|
||||
file.setLength(size)
|
||||
}
|
||||
ledger.persistLocked()
|
||||
}
|
||||
return ledger
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fun download(
|
||||
context: Context,
|
||||
resolver: ContentResolver,
|
||||
@@ -51,7 +146,7 @@ object DownloadClient {
|
||||
val expectedSha = requireNotNull(pairing.sha256)
|
||||
val partial = partialFile(context, pairing.session)
|
||||
partial.parentFile?.let { if (!it.exists() && !it.mkdirs()) error("无法创建接收缓存目录") }
|
||||
if (partial.length() > expectedSize) partial.delete()
|
||||
if (partial.length() > expectedSize) discardTransferState(partial)
|
||||
|
||||
// 落盘时缓存文件与目标文件同时存在,需要约 2 倍空间。
|
||||
// 不预检的话,这里会在下载 100% 之后才失败,用户看到的是「快结束时失败」。
|
||||
@@ -72,13 +167,13 @@ object DownloadClient {
|
||||
// 这一步失败与网络无关,重下多少次都没用,直接如实报错
|
||||
throw SaveFailure("文件已完整收到,但保存到 Downloads/QFT 失败:${failureDetail(e)}", e)
|
||||
}
|
||||
partial.delete()
|
||||
discardTransferState(partial)
|
||||
Log.i(TAG, "completed size=$expectedSize")
|
||||
return result
|
||||
}
|
||||
|
||||
Log.w(TAG, "sha mismatch round=${round + 1}/$VERIFY_ROUNDS expected=$expectedSha actual=$actual")
|
||||
partial.delete()
|
||||
discardTransferState(partial)
|
||||
if (round + 1 >= VERIFY_ROUNDS) {
|
||||
error("文件校验失败:重新完整下载后 SHA-256 仍不匹配,请让电脑重新生成二维码")
|
||||
}
|
||||
@@ -88,7 +183,8 @@ object DownloadClient {
|
||||
}
|
||||
|
||||
/** 传输阶段:断点续传 + 有限重试。只有这一段的失败才算「下载失败」。 */
|
||||
private fun receiveUntilComplete(
|
||||
@Suppress("unused")
|
||||
private fun receiveSequentialCompatibility(
|
||||
network: Network?,
|
||||
baseUrl: String,
|
||||
pairing: PairingPayload,
|
||||
@@ -234,6 +330,185 @@ object DownloadClient {
|
||||
}
|
||||
|
||||
/** 校验也要报进度:大文件读一整遍是好几秒,静默的话看起来就是卡在 100%。 */
|
||||
private fun receiveUntilComplete(
|
||||
network: Network?,
|
||||
baseUrl: String,
|
||||
pairing: PairingPayload,
|
||||
deviceName: String,
|
||||
partial: File,
|
||||
expectedSize: Long,
|
||||
abortReason: () -> String?,
|
||||
onProgress: (received: Long, total: Long) -> Unit,
|
||||
) {
|
||||
val ledger = ChunkLedger.open(partial, expectedSize, desiredRangeChunkSize(expectedSize))
|
||||
val initial = ledger.bytesComplete()
|
||||
onProgress(initial, expectedSize)
|
||||
if (ledger.allComplete()) return
|
||||
|
||||
val workers = ledger.totalChunks.coerceAtMost(RANGE_WORKERS).coerceAtLeast(1)
|
||||
Log.i(TAG, "parallel start: chunks=${ledger.totalChunks}, workers=$workers, completed=$initial/$expectedSize")
|
||||
val pool = Executors.newFixedThreadPool(workers)
|
||||
val next = AtomicInteger(0)
|
||||
val futures = (0 until workers).map {
|
||||
pool.submit {
|
||||
while (!Thread.currentThread().isInterrupted) {
|
||||
abortReason()?.let { error(it) }
|
||||
val index = next.getAndIncrement()
|
||||
if (index >= ledger.totalChunks) break
|
||||
if (ledger.isComplete(index)) continue
|
||||
receiveRangeWithRetry(
|
||||
network,
|
||||
baseUrl,
|
||||
pairing,
|
||||
deviceName,
|
||||
partial,
|
||||
expectedSize,
|
||||
ledger,
|
||||
index,
|
||||
abortReason,
|
||||
)
|
||||
onProgress(ledger.bytesComplete(), expectedSize)
|
||||
}
|
||||
}
|
||||
}
|
||||
try {
|
||||
futures.forEach { future -> future.get() }
|
||||
} catch (e: Exception) {
|
||||
futures.forEach { it.cancel(true) }
|
||||
throw (e.cause ?: e)
|
||||
} finally {
|
||||
pool.shutdownNow()
|
||||
}
|
||||
if (!ledger.allComplete()) {
|
||||
error("并行下载未完成:${ledger.bytesComplete()}/$expectedSize")
|
||||
}
|
||||
Log.i(TAG, "parallel complete: chunks=${ledger.totalChunks}, bytes=$expectedSize")
|
||||
}
|
||||
|
||||
private fun receiveRangeWithRetry(
|
||||
network: Network?,
|
||||
baseUrl: String,
|
||||
pairing: PairingPayload,
|
||||
deviceName: String,
|
||||
partial: File,
|
||||
expectedSize: Long,
|
||||
ledger: ChunkLedger,
|
||||
index: Int,
|
||||
abortReason: () -> String?,
|
||||
) {
|
||||
var last: Exception? = null
|
||||
repeat(RANGE_ATTEMPTS) { attempt ->
|
||||
abortReason()?.let { throw IllegalStateException(it, last) }
|
||||
try {
|
||||
receiveRange(
|
||||
network,
|
||||
baseUrl,
|
||||
pairing,
|
||||
deviceName,
|
||||
partial,
|
||||
expectedSize,
|
||||
ledger,
|
||||
index,
|
||||
)
|
||||
ledger.markComplete(index)
|
||||
return
|
||||
} catch (e: Exception) {
|
||||
last = e
|
||||
Log.w(
|
||||
TAG,
|
||||
"range=$index/${ledger.totalChunks} attempt=${attempt + 1}/$RANGE_ATTEMPTS failed: ${failureDetail(e)}",
|
||||
e,
|
||||
)
|
||||
if (attempt + 1 < RANGE_ATTEMPTS) {
|
||||
try {
|
||||
Thread.sleep(180L * (attempt + 1))
|
||||
} catch (interrupted: InterruptedException) {
|
||||
Thread.currentThread().interrupt()
|
||||
throw e
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
throw IllegalStateException(
|
||||
"分块 $index 下载失败,已重试 $RANGE_ATTEMPTS 次:${failureDetail(last)}",
|
||||
last,
|
||||
)
|
||||
}
|
||||
|
||||
private fun receiveRange(
|
||||
network: Network?,
|
||||
baseUrl: String,
|
||||
pairing: PairingPayload,
|
||||
deviceName: String,
|
||||
partial: File,
|
||||
expectedSize: Long,
|
||||
ledger: ChunkLedger,
|
||||
index: Int,
|
||||
) {
|
||||
val offset = ledger.chunkOffset(index)
|
||||
val length = ledger.chunkLength(index)
|
||||
val end = offset + length - 1L
|
||||
val conn = open(network, URL("$baseUrl/qft/download"))
|
||||
try {
|
||||
conn.requestMethod = "GET"
|
||||
conn.connectTimeout = 5_000
|
||||
conn.readTimeout = 20_000
|
||||
conn.useCaches = false
|
||||
conn.setRequestProperty("Connection", "close")
|
||||
conn.setRequestProperty("X-QFT-Token", pairing.session)
|
||||
conn.setRequestProperty("X-QFT-Device", Base64Url.encode(deviceName.toByteArray(Charsets.UTF_8)))
|
||||
conn.setRequestProperty("Range", "bytes=$offset-$end")
|
||||
|
||||
val code = conn.responseCode
|
||||
if (code != HttpURLConnection.HTTP_PARTIAL) {
|
||||
val message = try { conn.errorStream?.bufferedReader()?.use { it.readText().take(300) } } catch (_: Exception) { null }
|
||||
error("电脑下载服务未返回并行 Range(HTTP $code)${message?.let { ": $it" } ?: ""}")
|
||||
}
|
||||
val expectedRange = "bytes $offset-$end/$expectedSize"
|
||||
if (conn.getHeaderField("Content-Range") != expectedRange) {
|
||||
error("下载服务返回了无效范围:${conn.getHeaderField("Content-Range")}")
|
||||
}
|
||||
if (conn.contentLengthLong >= 0L && conn.contentLengthLong != length) {
|
||||
error("分块 $index 长度不匹配:${conn.contentLengthLong} != $length")
|
||||
}
|
||||
|
||||
var received = 0L
|
||||
conn.inputStream.use { input ->
|
||||
RandomAccessFile(partial, "rw").use { output ->
|
||||
output.channel.use { channel ->
|
||||
channel.position(offset)
|
||||
val buffer = ByteArray(BUFFER_SIZE)
|
||||
while (received < length) {
|
||||
val n = input.read(buffer, 0, minOf(buffer.size.toLong(), length - received).toInt())
|
||||
if (n < 0) break
|
||||
if (n == 0) continue
|
||||
val bytes = ByteBuffer.wrap(buffer, 0, n)
|
||||
while (bytes.hasRemaining()) channel.write(bytes)
|
||||
received += n.toLong()
|
||||
}
|
||||
channel.force(false)
|
||||
}
|
||||
}
|
||||
}
|
||||
if (received != length) error("分块 $index 提前结束:$received/$length")
|
||||
Log.d(TAG, "range=$index/${ledger.totalChunks} complete bytes=$length")
|
||||
} finally {
|
||||
conn.disconnect()
|
||||
}
|
||||
}
|
||||
|
||||
private fun desiredRangeChunkSize(fileSize: Long): Long {
|
||||
if (fileSize <= 0L) return MIN_RANGE_CHUNK
|
||||
return ((fileSize + RANGE_WORKERS - 1L) / RANGE_WORKERS)
|
||||
.coerceIn(MIN_RANGE_CHUNK, MAX_RANGE_CHUNK)
|
||||
}
|
||||
|
||||
private fun discardTransferState(partial: File) {
|
||||
partial.delete()
|
||||
File("${partial.path}.map").delete()
|
||||
File("${partial.path}.map.tmp").delete()
|
||||
}
|
||||
|
||||
private fun sha256(file: File, onProgress: (Long, Long) -> Unit): String {
|
||||
val digest = MessageDigest.getInstance("SHA-256")
|
||||
val total = file.length()
|
||||
|
||||
@@ -193,7 +193,7 @@ class MainActivity : ComponentActivity() {
|
||||
) { showReceivedFiles() })
|
||||
root.addView(space(22))
|
||||
root.addView(text("本机设备:$receiverDeviceLabel", 13f, MUTED))
|
||||
root.addView(text("QFT v0.4.6 · Android 7+ 到最新", 12f, MUTED))
|
||||
root.addView(text("QFT v0.4.7 · Android 7+ 到最新", 12f, MUTED))
|
||||
setContentView(ScrollView(this).apply { setBackgroundColor(BG); addView(root) })
|
||||
}
|
||||
|
||||
@@ -732,7 +732,7 @@ class MainActivity : ComponentActivity() {
|
||||
root.addView(card().apply {
|
||||
addView(text("连接状态", 14f, MUTED))
|
||||
addView(text("● 本地直连已就绪", 17f, SUCCESS, true), matchWrap(top = 8))
|
||||
addView(text(if (pair.version >= 2) "Parallel v2 · 自适应最高 8 路并发 · 4/8/16 MiB 自适应分块" else "兼容单流模式", 13f, ACCENT), matchWrap(top = 5))
|
||||
addView(text(if (pair.version >= 2) "Parallel v2 · 目标 8 路并发 · 64 KiB–16 MiB 自适应分块" else "兼容单流模式", 13f, ACCENT), matchWrap(top = 5))
|
||||
addView(text("目标:$baseUrl", 12f, MUTED), matchWrap(top = 6))
|
||||
pair.wifi?.let { addView(text("QFT 临时网络:${it.ssid}", 12f, MUTED), matchWrap(top = 4)) }
|
||||
})
|
||||
|
||||
@@ -31,14 +31,10 @@ data class SelectedFile(
|
||||
object UploadClient {
|
||||
private const val TAG = "QftUpload"
|
||||
private const val DISCOVERY_PORT = 39392
|
||||
private const val CHUNK_SMALL = 4L * 1024L * 1024L
|
||||
private const val CHUNK_DEFAULT = 8L * 1024L * 1024L
|
||||
private const val CHUNK_LARGE = 16L * 1024L * 1024L
|
||||
private const val MAX_WORKERS = 8
|
||||
private const val MIN_PARALLEL_CHUNK = 64L * 1024L
|
||||
private const val MAX_PARALLEL_CHUNK = 16L * 1024L * 1024L
|
||||
private const val STREAM_BUFFER = 1024 * 1024
|
||||
// A single request is materially more reliable for small files on Wi-Fi
|
||||
// Direct, and a 4 MiB parallel chunk gives no throughput benefit there.
|
||||
private const val PARALLEL_MIN_FILE_SIZE = 32L * 1024L * 1024L
|
||||
// QFT Direct can briefly reset a TCP flow while the Android network route
|
||||
// settles. Chunk PUTs and the init/finish control calls are safe to retry;
|
||||
// the Windows receiver treats a repeated chunk as an idempotent success.
|
||||
@@ -227,7 +223,7 @@ object UploadClient {
|
||||
file: SelectedFile,
|
||||
onProgress: (sent: Long, total: Long) -> Unit,
|
||||
) {
|
||||
if (pairing.version >= 2 && file.size >= PARALLEL_MIN_FILE_SIZE && isSeekable(resolver, file)) {
|
||||
if (pairing.version >= 2 && isSeekable(resolver, file)) {
|
||||
try {
|
||||
uploadParallel(resolver, network, baseUrl, pairing, deviceName, file, onProgress)
|
||||
return
|
||||
@@ -241,7 +237,7 @@ object UploadClient {
|
||||
if (!message.contains("HTTP 404") && !message.contains("HTTP 501")) throw e
|
||||
}
|
||||
}
|
||||
Log.i(TAG, "using single-stream upload: size=${file.size}, endpoint=$baseUrl")
|
||||
Log.i(TAG, "using compatibility single-stream upload: size=${file.size}, endpoint=$baseUrl")
|
||||
uploadLegacy(resolver, network, baseUrl, pairing, deviceName, file, onProgress)
|
||||
}
|
||||
|
||||
@@ -350,10 +346,13 @@ object UploadClient {
|
||||
}
|
||||
|
||||
|
||||
private fun desiredChunkSize(fileSize: Long): Long = when {
|
||||
fileSize < 32L * 1024L * 1024L -> CHUNK_SMALL
|
||||
fileSize >= 512L * 1024L * 1024L -> CHUNK_LARGE
|
||||
else -> CHUNK_DEFAULT
|
||||
private fun desiredChunkSize(fileSize: Long): Long {
|
||||
if (fileSize <= 0L) return MIN_PARALLEL_CHUNK
|
||||
// Aim for eight independent HTTP flows on every transferable file.
|
||||
// The floor keeps QR Direct overhead reasonable for tiny files, while
|
||||
// the ceiling protects memory and TCP fairness on very large files.
|
||||
return ((fileSize + MAX_WORKERS - 1) / MAX_WORKERS)
|
||||
.coerceIn(MIN_PARALLEL_CHUNK, MAX_PARALLEL_CHUNK)
|
||||
}
|
||||
|
||||
private fun initUpload(
|
||||
|
||||
Reference in New Issue
Block a user