数据压缩与缓存策略：把带宽用到极致

// ❌ 错误示范：手动设Accept-Encoding会关闭OkHttp的自动解压
val badRequest = Request.Builder()
.url("https://api.example.com/data")
.header("Accept-Encoding", "gzip") // 这会禁用OkHttp自动解压！
.build()
// 你需要手动用GzipSource解压response.body——何必呢？// ✅ 正确做法：什么都不做，OkHttp自动搞定
val goodRequest = Request.Builder()
.url("https://api.example.com/data")
.build()
// OkHttp自动加Accept-Encoding: gzip
// 自动检测Content-Encoding: gzip并解压
// response.body()返回的就是解压后的数据

// build.gradle.kts
implementation("org.brotli:dec:0.1.2")// Brotli解压拦截器
class BrotliInterceptor : Interceptor {
override fun intercept(chain: Interceptor.Chain): Response {
val request = chain.request().newBuilder()
.header("Accept-Encoding", "br, gzip") // 优先Brotli，降级Gzip
.build()
val response = chain.proceed(request)
val encoding = response.header("Content-Encoding")
if (encoding == "br") {
val body = response.body ?: return response
val decompressed = BrotliInputStream(body.byteStream())
val newBody = decompressed.readBytes()
.toResponseBody(body.contentType())
return response.newBuilder()
.removeHeader("Content-Encoding")
.body(newBody)
.build()
}
return response
}
}val client = OkHttpClient.Builder()
.addInterceptor(BrotliInterceptor())
.build()

// user.proto
syntax = "proto3";message UserList {
repeated User users = 1;
}message User {
int64  id        = 1;
string name      = 2;
string avatar    = 3;
int32  level     = 4;
int64  lastLogin = 5;
}// Retrofit + Protobuf配置
val retrofit = Retrofit.Builder()
.baseUrl("https://api.example.com/")
.addConverterFactory(ProtoConverterFactory.create()) // Wire或官方protobuf-lite
.client(client)
.build()interface UserApi {
@GET("users")
suspend fun getUsers(): UserList // 直接反序列化成Proto对象
}

// 启用OkHttp磁盘缓存
val cacheDir = File(context.cacheDir, "http_cache")
val cacheSize = 50L * 1024 * 1024 // 50MB
val cache = Cache(cacheDir, cacheSize)val client = OkHttpClient.Builder()
.cache(cache)
.build()// 就这么简单。OkHttp会自动：
// 1. 解析响应的Cache-Control / Expires / ETag / Last-Modified
// 2. 缓存满足条件的GET响应到磁盘
// 3. 后续请求自动判断是走强缓存还是协商缓存

/**
* 分场景缓存策略
*/
object CacheStrategy {// 配置类接口：强缓存1小时，过期后协商
val CONFIG = CacheControl.Builder()
.maxAge(1, TimeUnit.HOURS)
.build()// 列表类接口：强缓存30秒，保证基本不闪白屏
val LIST = CacheControl.Builder()
.maxAge(30, TimeUnit.SECONDS)
.build()// 实时接口：跳过强缓存，但仍走协商缓存（304）
val REALTIME = CacheControl.Builder()
.maxAge(0, TimeUnit.SECONDS) // 等于must-revalidate
.build()// 完全不缓存（支付、验证码等敏感接口）
val NO_CACHE = CacheControl.FORCE_NETWORK
}// 使用方式
val configRequest = Request.Builder()
.url("https://api.example.com/config")
.cacheControl(CacheStrategy.CONFIG)
.build()val feedRequest = Request.Builder()
.url("https://api.example.com/feed")
.cacheControl(CacheStrategy.LIST)
.build()

/**
* 网络感知的缓存拦截器
* 有网：正常请求（走协商缓存）
* 断网：使用过期缓存兜底
*/
class OfflineCacheInterceptor(
private val context: Context
) : Interceptor {override fun intercept(chain: Interceptor.Chain): Response {
var request = chain.request()if (!isNetworkAvailable(context)) {
// 断网时：允许使用7天内的过期缓存
request = request.newBuilder()
.cacheControl(
CacheControl.Builder()
.maxStale(7, TimeUnit.DAYS)
.build()
)
.build()
}
return chain.proceed(request)
}private fun isNetworkAvailable(context: Context): Boolean {
val cm = context.getSystemService<ConnectivityManager>()
return cm?.activeNetwork != null
}
}val client = OkHttpClient.Builder()
.cache(cache)
.addInterceptor(OfflineCacheInterceptor(context)) // application拦截器
.build()

/**
* 增量拉取方案
* 核心：客户端告知"我本地最新的数据版本号/时间戳"，服务端只返回增量部分
*/
interface MessageApi {
// 首次拉取：全量
@GET("messages")
suspend fun getMessages(
@Query("limit") limit: Int = 50
): MessageResponse// 增量拉取：只返回sinceVersion之后的数据
@GET("messages/incremental")
suspend fun getMessagesIncremental(
@Query("since_version") sinceVersion: Long,
@Query("limit") limit: Int = 100
): IncrementalResponse
}data class IncrementalResponse(
val added: List<Message>,     // 新增
val updated: List<Message>,   // 修改
val deletedIds: List<Long>,   // 删除
val currentVersion: Long     // 服务端最新版本号
)/**
* Repository层：自动判断全量/增量
*/
class MessageRepository(
private val api: MessageApi,
private val dao: MessageDao,
private val prefs: SharedPreferences
) {
suspend fun syncMessages() {
val localVersion = prefs.getLong("msg_version", 0L)if (localVersion == 0L) {
// 首次：全量拉取
val resp = api.getMessages()
dao.insertAll(resp.messages)
prefs.edit { putLong("msg_version", resp.version) }
} else {
// 后续：增量拉取
val resp = api.getMessagesIncremental(localVersion)
dao.insertAll(resp.added)
dao.updateAll(resp.updated)
dao.deleteByIds(resp.deletedIds)
prefs.edit { putLong("msg_version", resp.currentVersion) }
}
}
}

/**
* 差分更新流程
*
* 1. 客户端上报本地资源版本hash
* 2. 服务端计算diff(oldVersion, newVersion)生成patch
* 3. 客户端下载patch，本地apply还原新版本
* 4. 校验新版本hash → 成功则替换，失败则全量下载
*/
class DiffUpdateManager(
private val context: Context
) {
suspend fun updateResource(resourceId: String): Boolean {
val localFile = getLocalResource(resourceId)
val localHash = localFile?.md5() ?: ""// 请求差分包
val patchInfo = api.checkUpdate(resourceId, localHash)when {
patchInfo.status == "up_to_date" -> return true
patchInfo.patchUrl != null -> {
// 差分更新：下载patch → apply → 校验
val patch = downloadFile(patchInfo.patchUrl)
val newFile = BsDiff.patch(localFile!!, patch)
if (newFile.md5() == patchInfo.targetHash) {
replaceResource(resourceId, newFile)
return true
}
// hash不匹配：降级全量
}
}
// 全量下载（首次安装或差分失败）
val fullFile = downloadFile(patchInfo.fullUrl!!)
replaceResource(resourceId, fullFile)
return true
}
}

/**
* 离线优先架构核心组件
*
* 数据流：UI → ViewModel → Repository → Room (本地优先)
*                                          ↓ (后台同步)
*                                     WorkManager → API
*/// 1. Entity：增加同步状态字段
@Entity(tableName = "notes")
data class NoteEntity(
@PrimaryKey val id: String = UUID.randomUUID().toString(),
val title: String,
val content: String,
val updatedAt: Long = System.currentTimeMillis(),
val syncStatus: SyncStatus = SyncStatus.PENDING // 关键！
)enum class SyncStatus { SYNCED, PENDING, CONFLICT }// 2. Repository：写操作先落库，再触发同步
class NoteRepository(
private val dao: NoteDao,
private val workManager: WorkManager
) {
// UI层调这个 → 立即生效（毫秒级）
suspend fun saveNote(note: NoteEntity) {
dao.upsert(note.copy(syncStatus = SyncStatus.PENDING))
// 触发后台同步（即使App被杀也会执行）
enqueueSyncWork()
}fun observeNotes(): Flow<List<NoteEntity>> = dao.observeAll()private fun enqueueSyncWork() {
val constraints = Constraints.Builder()
.setRequiredNetworkType(NetworkType.CONNECTED)
.build()
val work = OneTimeWorkRequestBuilder<SyncWorker>()
.setConstraints(constraints)
.setBackoffCriteria(
BackoffPolicy.EXPONENTIAL,
30, TimeUnit.SECONDS
)
.build()
workManager.enqueueUniqueWork(
"note_sync",
ExistingWorkPolicy.REPLACE,
work
)
}
}// 3. SyncWorker：网络恢复时自动执行
class SyncWorker(
context: Context,
params: WorkerParameters
) : CoroutineWorker(context, params) {override suspend fun doWork(): Result {
val pending = dao.getPending() // 所有PENDING的笔记
return try {
pending.forEach { note ->
api.syncNote(note.toRequest())
dao.updateStatus(note.id, SyncStatus.SYNCED)
}
Result.success()
} catch (e: IOException) {
Result.retry() // WorkManager会按指数退避重试
}
}
}

/**
* 图片加载最佳实践（Coil 3.x示例）
*/
val imageLoader = ImageLoader.Builder(context)
.components {
// 支持AVIF解码（Android 12+自动启用）
if (Build.VERSION.SDK_INT >= 31) {
add(AvifDecoder.Factory())
}
}
.diskCache {
DiskCache.Builder()
.directory(context.cacheDir.resolve("image_cache"))
.maxSizeBytes(256L * 1024 * 1024) // 256MB磁盘缓存
.build()
}
.memoryCachePolicy(CachePolicy.ENABLED)
.diskCachePolicy(CachePolicy.ENABLED)
.crossfade(true)
.build()/**
* CDN URL 动态适配
* 根据设备能力和屏幕尺寸生成最优图片URL
*/
fun buildImageUrl(
originalUrl: String,
widthPx: Int,
context: Context
): String {
val format = when {
Build.VERSION.SDK_INT >= 31 -> "avif"
else -> "webp"
}
val density = context.resources.displayMetrics.density
val targetWidth = (widthPx * density).toInt()
// 大多数CDN支持URL参数控制格式和尺寸
return "${originalUrl}?format=${format}&w=${targetWidth}&q=80"
}

/**
* BlurHash渐进式加载方案
*
* 后端为每张图生成BlurHash字符串（20-30字节），随接口一起下发
* 客户端立即渲染模糊占位图 → 异步加载真图 → crossfade过渡
*/
@Composable
fun ProgressiveImage(
imageUrl: String,
blurHash: String?, // "LEHLk~WB2yk8pyo0adR*.7kCMdnj" — 约25字节
modifier: Modifier = Modifier
) {
val placeholder = remember(blurHash) {
blurHash?.let { BlurHashDecoder.decode(it, 32, 32) }
}AsyncImage(
model = ImageRequest.Builder(LocalContext.current)
.data(imageUrl)
.placeholder(placeholder?.let { BitmapDrawable(it) })
.crossfade(300)
.build(),
contentDescription = null,
modifier = modifier,
contentScale = ContentScale.Crop
)
}// 接口返回示例：
// { "imageUrl": "https://cdn.../photo.webp", "blurHash": "LEHLk~WB2yk8..." }
// blurHash只有25字节，但能渲染出辨识度极高的模糊缩略图