android 离屏预渲染笔记

Android 离屏预渲染深度解析与优化实践

离屏预渲染（Off-screen Pre-rendering）是Android性能优化中的重要技术，可以在后台提前准备视图，显著提升UI流畅性和响应速度。

一、离屏预渲染核心概念

1. 什么是离屏预渲染

定义：在屏幕外提前创建、布局和绘制UI组件，然后在需要时直接显示
目标：减少主线程阻塞，避免UI卡顿，实现平滑的页面切换和滚动
应用场景 ：
- 复杂布局的提前准备
- 列表项（RecyclerView/ListView）预加载
- 页面切换动画优化
- 3D/游戏场景的预渲染

2. 渲染流水线与预渲染

scss 复制代码

传统渲染流程：
1. 创建View对象 (CPU)
2. 测量(Measure) + 布局(Layout) (CPU)
3. 绘制(Draw) → 生成DrawOp (CPU)
4. 合成(Composite) → OpenGL/DirectX (GPU)
5. 显示(Swap Buffer) (Display)

离屏预渲染：
在步骤1-4完成后，将结果缓存为Bitmap/Texture
需要显示时直接使用缓存结果

二、核心实现方案

1. Bitmap预渲染方案

基础实现

kotlin 复制代码

class OffscreenRenderer(private val context: Context) {
    
    companion object {
        private const val PRE_RENDER_CACHE_SIZE = 5
    }
    
    private val renderCache = LruCache<Int, Bitmap>(PRE_RENDER_CACHE_SIZE)
    private val executor = Executors.newFixedThreadPool(2)
    
    /**
     * 预渲染View为Bitmap
     */
    fun preRenderView(
        @LayoutRes layoutId: Int,
        width: Int,
        height: Int,
        config: Bitmap.Config = Bitmap.Config.ARGB_8888
    ) {
        executor.execute {
            val bitmap = renderViewToBitmap(layoutId, width, height, config)
            synchronized(renderCache) {
                renderCache.put(layoutId, bitmap)
            }
        }
    }
    
    /**
     * 将View渲染为Bitmap
     */
    private fun renderViewToBitmap(
        @LayoutRes layoutId: Int,
        width: Int,
        height: Int,
        config: Bitmap.Config
    ): Bitmap {
        // 1. 创建Bitmap
        val bitmap = Bitmap.createBitmap(width, height, config)
        
        // 2. 创建Canvas并关联Bitmap
        val canvas = Canvas(bitmap)
        
        // 3. 加载布局
        val view = LayoutInflater.from(context)
            .inflate(layoutId, null, false)
        
        // 4. 测量和布局
        val widthSpec = View.MeasureSpec.makeMeasureSpec(
            width, 
            View.MeasureSpec.EXACTLY
        )
        val heightSpec = View.MeasureSpec.makeMeasureSpec(
            height, 
            View.MeasureSpec.EXACTLY
        )
        
        view.measure(widthSpec, heightSpec)
        view.layout(0, 0, view.measuredWidth, view.measuredHeight)
        
        // 5. 绘制到Canvas
        view.draw(canvas)
        
        return bitmap
    }
    
    /**
     * 获取预渲染的Bitmap
     */
    fun getRenderedBitmap(@LayoutRes layoutId: Int): Bitmap? {
        return synchronized(renderCache) {
            renderCache.get(layoutId)
        }
    }
    
    /**
     * 清理缓存
     */
    fun clearCache() {
        synchronized(renderCache) {
            renderCache.evictAll()
        }
    }
}

// 使用示例
class MainActivity : AppCompatActivity() {
    private lateinit var renderer: OffscreenRenderer
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        
        renderer = OffscreenRenderer(this)
        
        // 在空闲时预渲染
        preRenderComplexViews()
        
        // 显示时直接使用预渲染结果
        showPreRenderedView()
    }
    
    private fun preRenderComplexViews() {
        // 预渲染多个可能用到的视图
        val screenWidth = resources.displayMetrics.widthPixels
        val screenHeight = resources.displayMetrics.heightPixels
        
        renderer.preRenderView(
            R.layout.complex_header,
            screenWidth,
            200.dpToPx()
        )
        
        renderer.preRenderView(
            R.layout.complex_item,
            screenWidth,
            100.dpToPx()
        )
    }
    
    private fun showPreRenderedView() {
        val bitmap = renderer.getRenderedBitmap(R.layout.complex_header)
        bitmap?.let {
            val imageView = findViewById<ImageView>(R.id.preview_view)
            imageView.setImageBitmap(it)
            
            // 或者直接作为View的背景
            // findViewById<ViewGroup>(R.id.container).background = BitmapDrawable(resources, it)
        }
    }
    
    private fun Int.dpToPx(): Int {
        val density = resources.displayMetrics.density
        return (this * density).toInt()
    }
}

2. TextureView预渲染方案

适合需要硬件加速的复杂渲染场景：

kotlin 复制代码

class TexturePreRenderer(private val context: Context) {
    
    private class RenderResult(
        val textureView: TextureView,
        val surfaceTexture: SurfaceTexture
    )
    
    private val renderQueue = LinkedBlockingQueue<RenderTask>()
    private val renderResults = ConcurrentHashMap<Int, RenderResult>()
    
    init {
        startRenderThread()
    }
    
    /**
     * 预渲染到TextureView
     */
    fun preRenderToTexture(
        @LayoutRes layoutId: Int,
        width: Int,
        height: Int,
        callback: (TextureView?) -> Unit
    ) {
        val task = RenderTask(layoutId, width, height, callback)
        renderQueue.offer(task)
    }
    
    private inner class RenderTask(
        val layoutId: Int,
        val width: Int,
        val height: Int,
        val callback: (TextureView?) -> Unit
    )
    
    private fun startRenderThread() {
        Thread({
            while (true) {
                try {
                    val task = renderQueue.take()
                    renderTextureTask(task)
                } catch (e: InterruptedException) {
                    break
                }
            }
        }, "TextureRenderThread").start()
    }
    
    private fun renderTextureTask(task: RenderTask) {
        // 必须在渲染线程中创建和使用TextureView
        Handler(Looper.getMainLooper()).post {
            val textureView = TextureView(context)
            textureView.layoutParams = ViewGroup.LayoutParams(
                task.width,
                task.height
            )
            
            textureView.surfaceTextureListener = object : TextureView.SurfaceTextureListener {
                override fun onSurfaceTextureAvailable(
                    surface: SurfaceTexture,
                    width: Int,
                    height: Int
                ) {
                    // 表面可用，开始渲染
                    renderToSurface(surface, task.layoutId, task.width, task.height)
                    
                    // 缓存结果
                    renderResults[task.layoutId] = RenderResult(textureView, surface)
                    
                    // 回调
                    task.callback(textureView)
                }
                
                override fun onSurfaceTextureSizeChanged(
                    surface: SurfaceTexture,
                    width: Int,
                    height: Int
                ) {
                    // 尺寸变化
                }
                
                override fun onSurfaceTextureDestroyed(surface: SurfaceTexture): Boolean {
                    // 清理资源
                    return true
                }
                
                override fun onSurfaceTextureUpdated(surface: SurfaceTexture) {
                    // 表面更新
                }
            }
            
            // 触发创建SurfaceTexture
            textureView.isOpaque = false
        }
    }
    
    private fun renderToSurface(
        surfaceTexture: SurfaceTexture,
        @LayoutRes layoutId: Int,
        width: Int,
        height: Int
    ) {
        // 创建Canvas并绘制到Surface
        val canvas = surfaceTexture.lockCanvas(null)
        try {
            // 设置Canvas变换（如果需要）
            canvas.save()
            
            // 加载并绘制View
            val view = LayoutInflater.from(context)
                .inflate(layoutId, null, false)
            
            view.measure(
                View.MeasureSpec.makeMeasureSpec(width, View.MeasureSpec.EXACTLY),
                View.MeasureSpec.makeMeasureSpec(height, View.MeasureSpec.EXACTLY)
            )
            view.layout(0, 0, width, height)
            
            view.draw(canvas)
            
            canvas.restore()
        } finally {
            surfaceTexture.unlockCanvasAndPost(canvas)
        }
    }
    
    fun getTextureView(@LayoutRes layoutId: Int): TextureView? {
        return renderResults[layoutId]?.textureView
    }
}

3. RecyclerView列表项预渲染

kotlin 复制代码

class RecyclerViewPreRenderer(
    private val recyclerView: RecyclerView,
    private val layoutManager: RecyclerView.LayoutManager
) {
    
    private val itemCache = LruCache<Int, Bitmap>(10)
    private val executor = Executors.newFixedThreadPool(3)
    private val preRenderRange = 3 // 预渲染前后3个item
    
    /**
     * 开始预渲染
     */
    fun startPreRendering(dataList: List<Any>) {
        recyclerView.addOnScrollListener(object : RecyclerView.OnScrollListener() {
            override fun onScrolled(recyclerView: RecyclerView, dx: Int, dy: Int) {
                super.onScrolled(recyclerView, dx, dy)
                updatePreRenderItems(dataList)
            }
        })
    }
    
    /**
     * 更新需要预渲染的项
     */
    private fun updatePreRenderItems(dataList: List<Any>) {
        val firstVisible = layoutManager.findFirstVisibleItemPosition()
        val lastVisible = layoutManager.findLastVisibleItemPosition()
        
        if (firstVisible == RecyclerView.NO_POSITION || 
            lastVisible == RecyclerView.NO_POSITION) {
            return
        }
        
        // 计算预渲染范围
        val preRenderStart = max(0, firstVisible - preRenderRange)
        val preRenderEnd = min(dataList.size - 1, lastVisible + preRenderRange)
        
        // 提交预渲染任务
        for (position in preRenderStart..preRenderEnd) {
            if (position < firstVisible || position > lastVisible) {
                // 只预渲染不可见的项
                if (!itemCache.containsKey(position)) {
                    preRenderItem(position, dataList[position])
                }
            }
        }
    }
    
    /**
     * 预渲染单个项
     */
    private fun preRenderItem(position: Int, data: Any) {
        executor.execute {
            val itemWidth = recyclerView.width
            val itemHeight = estimateItemHeight(position, data)
            
            val bitmap = renderItemToBitmap(position, data, itemWidth, itemHeight)
            
            synchronized(itemCache) {
                itemCache.put(position, bitmap)
            }
        }
    }
    
    /**
     * 渲染Item为Bitmap
     */
    private fun renderItemToBitmap(
        position: Int,
        data: Any,
        width: Int,
        height: Int
    ): Bitmap? {
        return try {
            val bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888)
            val canvas = Canvas(bitmap)
            
            // 创建ViewHolder（使用Adapter的创建方法）
            val adapter = recyclerView.adapter ?: return null
            
            val viewHolder = adapter.onCreateViewHolder(recyclerView, getItemViewType(position))
            
            // 绑定数据
            adapter.onBindViewHolder(viewHolder, position)
            
            // 测量和布局
            viewHolder.itemView.measure(
                View.MeasureSpec.makeMeasureSpec(width, View.MeasureSpec.EXACTLY),
                View.MeasureSpec.makeMeasureSpec(height, View.MeasureSpec.EXACTLY)
            )
            viewHolder.itemView.layout(0, 0, width, height)
            
            // 绘制
            viewHolder.itemView.draw(canvas)
            
            bitmap
        } catch (e: Exception) {
            null
        }
    }
    
    /**
     * 在Adapter中使用预渲染
     */
    class PreRenderAdapter : RecyclerView.Adapter<ViewHolder>() {
        
        private val preRenderer: RecyclerViewPreRenderer? = null
        
        override fun onBindViewHolder(holder: ViewHolder, position: Int) {
            // 检查是否有预渲染结果
            val cachedBitmap = preRenderer?.getCachedBitmap(position)
            
            if (cachedBitmap != null) {
                // 使用预渲染的Bitmap快速显示
                showPreRenderedView(holder, cachedBitmap)
                
                // 异步加载实际内容
                loadRealContentAsync(holder, position)
            } else {
                // 正常加载
                loadContent(holder, position)
            }
        }
        
        private fun showPreRenderedView(holder: ViewHolder, bitmap: Bitmap) {
            holder.itemView.background = BitmapDrawable(
                holder.itemView.context.resources,
                bitmap
            )
        }
    }
    
    fun getCachedBitmap(position: Int): Bitmap? {
        return itemCache.get(position)
    }
    
    private fun estimateItemHeight(position: Int, data: Any): Int {
        // 根据数据类型估算高度
        return 100 // 默认高度
    }
    
    private fun getItemViewType(position: Int): Int {
        return recyclerView.adapter?.getItemViewType(position) ?: 0
    }
}

4. ViewStub + 预渲染组合方案

kotlin 复制代码

class AdvancedPreRenderer(private val activity: Activity) {
    
    private val viewPool = ViewPool(activity)
    private val bitmapCache = BitmapCache()
    
    /**
     * 使用ViewPool预创建View
     */
    class ViewPool(private val context: Context) {
        private val viewQueueMap = mutableMapOf<Int, ConcurrentLinkedQueue<View>>()
        private val maxPoolSize = 5
        
        fun acquire(@LayoutRes layoutId: Int): View? {
            val queue = viewQueueMap[layoutId] ?: run {
                val newQueue = ConcurrentLinkedQueue<View>()
                viewQueueMap[layoutId] = newQueue
                newQueue
            }
            
            return queue.poll() ?: createView(layoutId)
        }
        
        fun release(@LayoutRes layoutId: Int, view: View) {
            val queue = viewQueueMap[layoutId] ?: return
            
            if (queue.size < maxPoolSize) {
                queue.offer(view)
            }
        }
        
        private fun createView(@LayoutRes layoutId: Int): View {
            return LayoutInflater.from(context).inflate(layoutId, null, false)
        }
    }
    
    /**
     * 高级预渲染：异步准备View
     */
    fun prepareViewAsync(
        @LayoutRes layoutId: Int,
        width: Int,
        height: Int,
        onReady: (View) -> Unit
    ) {
        CoroutineScope(Dispatchers.IO).launch {
            // 1. 尝试从池中获取View
            var view = viewPool.acquire(layoutId)
            
            if (view == null) {
                // 2. 创建新View
                view = LayoutInflater.from(activity).inflate(layoutId, null, false)
            }
            
            // 3. 测量和布局（在后台线程）
            view.measure(
                View.MeasureSpec.makeMeasureSpec(width, View.MeasureSpec.EXACTLY),
                View.MeasureSpec.makeMeasureSpec(height, View.MeasureSpec.EXACTLY)
            )
            view.layout(0, 0, width, height)
            
            // 4. 预绘制到Bitmap（可选）
            if (shouldPreDraw(layoutId)) {
                preDrawToBitmap(view, layoutId, width, height)
            }
            
            // 5. 回到主线程
            withContext(Dispatchers.Main) {
                onReady(view)
            }
        }
    }
    
    /**
     * 预绘制为Bitmap并缓存
     */
    private fun preDrawToBitmap(view: View, @LayoutRes layoutId: Int, width: Int, height: Int) {
        val bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888)
        val canvas = Canvas(bitmap)
        view.draw(canvas)
        bitmapCache.put(layoutId, bitmap)
    }
}

// 使用示例：预加载Fragment视图
class FragmentPreLoader {
    
    private val fragmentCache = mutableMapOf<String, Fragment>()
    private val viewCache = mutableMapOf<String, View>()
    
    fun preLoadFragment(fragmentClass: Class<out Fragment>, tag: String) {
        CoroutineScope(Dispatchers.Main).launch {
            try {
                // 提前创建Fragment
                val fragment = fragmentClass.newInstance()
                
                // 提前创建View（但不添加到视图树）
                val view = fragment.onCreateView(
                    LayoutInflater.from(Application.context),
                    null,
                    null
                )
                
                // 缓存
                fragmentCache[tag] = fragment
                viewCache[tag] = view
                
                // 可选：预执行Fragment生命周期方法
                fragment.onViewCreated(view, null)
                
            } catch (e: Exception) {
                e.printStackTrace()
            }
        }
    }
    
    fun getPreLoadedFragment(tag: String): Fragment? {
        return fragmentCache[tag]
    }
}

三、性能优化与最佳实践

1. 内存管理策略

kotlin 复制代码

class SmartBitmapCache {
    
    companion object {
        // 根据设备内存动态计算缓存大小
        private fun calculateCacheSize(): Int {
            val activityManager = Application.context
                .getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager
            
            val isLowMemoryDevice = activityManager.isLowRamDevice
            val maxMemory = Runtime.getRuntime().maxMemory() / 1024 / 1024 // MB
            
            return when {
                isLowMemoryDevice -> 8 // 8MB
                maxMemory <= 1024 -> 16 // 16MB
                maxMemory <= 2048 -> 32 // 32MB
                else -> 64 // 64MB
            }
        }
    }
    
    private val memoryCache = object : LruCache<String, Bitmap>(calculateCacheSize() * 1024 * 1024) {
        override fun sizeOf(key: String, bitmap: Bitmap): Int {
            return bitmap.byteCount
        }
        
        override fun entryRemoved(
            evicted: Boolean,
            key: String,
            oldValue: Bitmap,
            newValue: Bitmap?
        ) {
            // 可以在这里回收Bitmap或放入二级缓存
            if (oldValue.isRecyclable) {
                oldValue.recycle()
            }
        }
    }
    
    private val diskCache = DiskLruCache.open(
        File(Application.context.cacheDir, "pre_render_cache"),
        1, // app版本
        1, // 每个key对应一个文件
        50 * 1024 * 1024 // 50MB磁盘缓存
    )
    
    /**
     * 智能获取Bitmap，支持内存和磁盘缓存
     */
    suspend fun getBitmap(key: String, renderBlock: suspend () -> Bitmap): Bitmap? {
        // 1. 检查内存缓存
        memoryCache.get(key)?.let { return it }
        
        // 2. 检查磁盘缓存
        val diskBitmap = getFromDiskCache(key)
        diskBitmap?.let {
            // 放入内存缓存
            memoryCache.put(key, it)
            return it
        }
        
        // 3. 执行渲染
        return withContext(Dispatchers.Default) {
            val bitmap = renderBlock()
            
            // 缓存结果
            memoryCache.put(key, bitmap)
            saveToDiskCache(key, bitmap)
            
            bitmap
        }
    }
}

2. 渲染优先级控制

kotlin 复制代码

class PriorityRenderManager {
    
    enum class RenderPriority {
        HIGH,     // 立即需要显示的
        MEDIUM,   // 即将显示的
        LOW       // 预加载的
    }
    
    private val highPriorityQueue = PriorityBlockingQueue<RenderTask>()
    private val mediumPriorityQueue = PriorityBlockingQueue<RenderTask>()
    private val lowPriorityQueue = PriorityBlockingQueue<RenderTask>()
    
    private val executors = mapOf(
        RenderPriority.HIGH to Executors.newFixedThreadPool(2),
        RenderPriority.MEDIUM to Executors.newFixedThreadPool(2),
        RenderPriority.LOW to Executors.newSingleThreadExecutor()
    )
    
    fun submitRenderTask(
        task: RenderTask,
        priority: RenderPriority = RenderPriority.MEDIUM
    ) {
        when (priority) {
            RenderPriority.HIGH -> {
                highPriorityQueue.put(task)
                executors[RenderPriority.HIGH]?.execute(createRunnable(highPriorityQueue))
            }
            RenderPriority.MEDIUM -> {
                mediumPriorityQueue.put(task)
                executors[RenderPriority.MEDIUM]?.execute(createRunnable(mediumPriorityQueue))
            }
            RenderPriority.LOW -> {
                lowPriorityQueue.put(task)
                executors[RenderPriority.LOW]?.execute(createRunnable(lowPriorityQueue))
            }
        }
    }
    
    private fun createRunnable(queue: PriorityBlockingQueue<RenderTask>): Runnable {
        return Runnable {
            try {
                val task = queue.take()
                task.execute()
            } catch (e: InterruptedException) {
                Thread.currentThread().interrupt()
            }
        }
    }
    
    class RenderTask(
        val key: String,
        val layoutId: Int,
        val width: Int,
        val height: Int,
        val callback: (Bitmap?) -> Unit
    ) : Comparable<RenderTask> {
        var priority = 0
        var timestamp = System.currentTimeMillis()
        
        fun execute() {
            // 执行渲染逻辑
        }
        
        override fun compareTo(other: RenderTask): Int {
            return if (priority != other.priority) {
                other.priority - priority // 优先级高的在前
            } else {
                (timestamp - other.timestamp).toInt() // 时间早的在前
            }
        }
    }
}

3. 生命周期感知渲染

kotlin 复制代码

class LifecycleAwareRenderer(
    private val lifecycleOwner: LifecycleOwner
) {
    
    private val jobMap = mutableMapOf<String, Job>()
    private val renderScope = CoroutineScope(Dispatchers.IO)
    
    init {
        lifecycleOwner.lifecycle.addObserver(object : DefaultLifecycleObserver {
            override fun onPause(owner: LifecycleOwner) {
                // 暂停低优先级渲染
                pauseLowPriorityRendering()
            }
            
            override fun onResume(owner: LifecycleOwner) {
                // 恢复渲染
                resumeRendering()
            }
            
            override fun onDestroy(owner: LifecycleOwner) {
                // 清理所有渲染任务
                cleanup()
            }
        })
    }
    
    fun renderWithLifecycle(
        key: String,
        block: suspend () -> Bitmap,
        priority: RenderPriority = RenderPriority.MEDIUM
    ): Job {
        
        val job = renderScope.launch {
            if (!isActive) return@launch
            
            try {
                val bitmap = block()
                
                // 检查生命周期状态
                if (lifecycleOwner.lifecycle.currentState.isAtLeast(Lifecycle.State.STARTED)) {
                    withContext(Dispatchers.Main) {
                        // 更新UI
                    }
                }
            } catch (e: CancellationException) {
                // 任务被取消
            }
        }
        
        jobMap[key] = job
        return job
    }
    
    private fun pauseLowPriorityRendering() {
        jobMap.forEach { (key, job) ->
            if (getPriority(key) == RenderPriority.LOW) {
                job.cancel()
            }
        }
    }
    
    private fun getPriority(key: String): RenderPriority {
        // 根据key判断优先级
        return RenderPriority.MEDIUM
    }
}

四、监控与调试

1. 性能监控工具

kotlin 复制代码

class RenderPerformanceMonitor {
    
    private val renderMetrics = mutableMapOf<String, RenderMetric>()
    
    data class RenderMetric(
        val layoutId: Int,
        val renderTime: Long,
        val memoryUsage: Long,
        val success: Boolean,
        val timestamp: Long = System.currentTimeMillis()
    )
    
    fun recordRender(
        layoutId: Int,
        block: () -> Bitmap?
    ): Bitmap? {
        val startTime = System.nanoTime()
        val startMemory = Runtime.getRuntime().totalMemory() - 
                         Runtime.getRuntime().freeMemory()
        
        var success = false
        val result = try {
            val bitmap = block()
            success = true
            bitmap
        } catch (e: Exception) {
            null
        }
        
        val endTime = System.nanoTime()
        val endMemory = Runtime.getRuntime().totalMemory() - 
                       Runtime.getRuntime().freeMemory()
        
        val metric = RenderMetric(
            layoutId = layoutId,
            renderTime = (endTime - startTime) / 1_000_000, // ms
            memoryUsage = endMemory - startMemory,
            success = success
        )
        
        renderMetrics["${layoutId}_${System.currentTimeMillis()}"] = metric
        
        // 定期清理旧数据
        cleanupOldMetrics()
        
        return result
    }
    
    fun getPerformanceReport(): String {
        return buildString {
            append("=== 预渲染性能报告 ===\n")
            append("总渲染次数: ${renderMetrics.size}\n")
            
            val successful = renderMetrics.values.count { it.success }
            append("成功次数: $successful\n")
            
            val averageTime = renderMetrics.values
                .map { it.renderTime }
                .average()
            append("平均渲染时间: ${"%.2f".format(averageTime)}ms\n")
            
            val maxMemory = renderMetrics.values
                .maxByOrNull { it.memoryUsage }?.memoryUsage ?: 0
            append("最大内存使用: ${maxMemory / 1024}KB\n")
        }
    }
}

2. 调试工具

kotlin 复制代码

// 在开发阶段使用的调试渲染器
class DebugOffscreenRenderer(context: Context) : OffscreenRenderer(context) {
    
    private var debugEnabled = BuildConfig.DEBUG
    
    override fun preRenderView(
        @LayoutRes layoutId: Int,
        width: Int,
        height: Int,
        config: Bitmap.Config
    ) {
        if (!debugEnabled) {
            super.preRenderView(layoutId, width, height, config)
            return
        }
        
        val startTime = System.currentTimeMillis()
        
        super.preRenderView(layoutId, width, height, config)
        
        val endTime = System.currentTimeMillis()
        val duration = endTime - startTime
        
        Log.d("PreRenderDebug", 
            "预渲染布局 $layoutId (${width}x$height) 耗时: ${duration}ms")
        
        // 验证渲染结果
        val bitmap = getRenderedBitmap(layoutId)
        if (bitmap != null && bitmap.width > 0 && bitmap.height > 0) {
            Log.d("PreRenderDebug", "渲染成功，Bitmap大小: ${bitmap.byteCount} bytes")
        } else {
            Log.w("PreRenderDebug", "渲染失败或结果为null")
        }
    }
}

五、最佳实践总结

1. 何时使用离屏预渲染

✅ 推荐使用 ：
- 复杂但静态的布局（如商品详情页、文章内容）
- 列表项样式统一且数量有限
- 页面切换需要平滑动画
- 低端设备上的性能优化
❌ 避免使用 ：
- 布局频繁变化或高度动态
- 简单布局（可能增加复杂度）
- 内存敏感的场景
- 需要实时交互的视图

2. 内存优化建议

使用合适的Bitmap配置：

kotlin 复制代码

// 根据需求选择
Bitmap.Config.ARGB_8888    // 质量最好，内存最大
Bitmap.Config.RGB_565      // 节省内存，不支持透明
Bitmap.Config.ARGB_4444    // 不建议使用

及时回收资源：

kotlin 复制代码

override fun onTrimMemory(level: Int) {
    when (level) {
        ComponentCallbacks2.TRIM_MEMORY_RUNNING_MODERATE,
        ComponentCallbacks2.TRIM_MEMORY_RUNNING_LOW -> {
            // 减少缓存大小
            renderCache.trimToSize(renderCache.maxSize() / 2)
        }
        ComponentCallbacks2.TRIM_MEMORY_RUNNING_CRITICAL -> {
            // 清空缓存
            renderCache.evictAll()
        }
    }
}

3. 线程安全注意事项

View的measure/layout/draw必须在同一线程完成
Bitmap操作注意线程安全
使用ConcurrentHashMap等线程安全集合

4. 兼容性考虑

kotlin 复制代码

fun isPreRenderSupported(): Boolean {
    // 检查设备能力
    return when {
        Build.VERSION.SDK_INT < Build.VERSION_CODES.O -> {
            // Android 8.0以下，硬件加速可能有问题
            false
        }
        Runtime.getRuntime().maxMemory() < 256 * 1024 * 1024 -> {
            // 内存小于256MB的设备
            false
        }
        else -> true
    }
}

离屏预渲染是强大的性能优化工具，但需要谨慎使用。始终遵循测量 → 优化 → 验证的流程，确保优化真正提升用户体验，而不是引入新的问题。

android 离屏预渲染 笔记

Android 离屏预渲染深度解析与优化实践

一、离屏预渲染核心概念

1. 什么是离屏预渲染

2. 渲染流水线与预渲染

二、核心实现方案

1. Bitmap预渲染方案

基础实现

2. TextureView预渲染方案

3. RecyclerView列表项预渲染

4. ViewStub + 预渲染组合方案

三、性能优化与最佳实践

1. 内存管理策略

2. 渲染优先级控制

3. 生命周期感知渲染

四、监控与调试

1. 性能监控工具

2. 调试工具

五、最佳实践总结

1. 何时使用离屏预渲染

2. 内存优化建议

3. 线程安全注意事项

4. 兼容性考虑

android 离屏预渲染笔记