Android中高级面试（三）：架构组件与性能优化实战

// ViewModelProvider 初始化示例
val viewModel = ViewModelProvider(
    this, 
    object : ViewModelProvider.Factory {
        override fun <T : ViewModel> create(modelClass: Class<T>): T {
            return MyViewModel(repository) as T
        }
    }
).get(MyViewModel::class.java)

class EventLiveData<T> : MutableLiveData<T>() {
    private val pendingMap = ConcurrentHashMap<Int, Boolean>()

    @MainThread
    override fun observe(owner: LifecycleOwner, observer: Observer<in T>) {
        val wrapper = ObserverWrapper(observer)
        super.observe(owner, wrapper)
    }

    inner class ObserverWrapper(val observer: Observer<in T>) : Observer<T> {
        override fun onChanged(t: T?) {
            if (pendingMap.hashCode() == false) return
            observer.onChanged(t)
        }
    }
}

fun <T> LiveData<T>.asFlow(): Flow<T> = callbackFlow {
    val observer = Observer<T> { value ->
        trySend(value).isSuccess // 将LiveData值发送到Flow
    }
    observeForever(observer)
    awaitClose { removeObserver(observer) }
}

// 使用示例
viewModel.data.asFlow()
    .filter { it.isValid() }
    .map { it.transform() }
    .launchIn(viewModelScope)

val MIGRATION_1_2 = object : Migration(1, 2) {
    override fun migrate(database: SupportSQLiteDatabase) {
        // 添加新表
        database.execSQL("CREATE TABLE IF NOT EXISTS `address` (`id` INTEGER PRIMARY KEY, `street` TEXT)")
        // 修改旧表结构
        database.execSQL("ALTER TABLE user ADD COLUMN phone TEXT DEFAULT ''")
    }
}

Room.databaseBuilder(context, AppDatabase::class.java, "sample.db")
    .addMigrations(MIGRATION_1_2)
    .addCallback(object : RoomDatabase.Callback() {
        override fun onCreate(db: SupportSQLiteDatabase) {
            // 初始化数据
        }
    })
    .build()

class CustomLeakCanary : AbstractLeakCanary() {
    override fun onLeakFound(heapAnalysis: HeapAnalysis) {
        // 自定义泄漏上报逻辑
        FirebaseCrashlytics.getInstance().log("Memory leak detected: ${heapAnalysis.signature}")
    }
}

// 配置示例
LeakCanary.config = LeakCanary.config.copy(
    dumpHeap = BuildConfig.DEBUG, // 仅Debug模式检测
    retainedVisibleThreshold = 3, // 泄漏阈值
    onHeapAnalyzedListener = CustomLeakCanary()
)

class ProductViewModel : ViewModel() {
    private val _products = MutableStateFlow<List<Product>>(emptyList())
    val products: StateFlow<List<Product>> = _products

    init {
        viewModelScope.launch(Dispatchers.IO + CoroutineExceptionHandler { _, e ->
            Log.e("CoroutineError", e.message)
        }) {
            val productJob = async { fetchProducts() }
            val promoJob = async { fetchPromotions() }

            // 合并网络请求结果
            _products.value = productJob.await()
                .combinePromotions(promoJob.await())
        }
    }

    private suspend fun fetchProducts() = withContext(Dispatchers.IO) {
        repository.getProducts().map { it.toDomainModel() }
    }
}

sealed interface UiState<out T> {
    object Loading : UiState<Nothing>
    data class Success<T>(val data: T) : UiState<T>
    data class Error(val exception: Throwable) : UiState<Nothing>
}

fun <T> Flow<T>.asStateFlow(): StateFlow<UiState<T>> {
    return this.map<T, UiState<T>> { UiState.Success(it) }
        .onStart { emit(UiState.Loading) }
        .catch { e -> emit(UiState.Error(e)) }
        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), UiState.Loading)
}

class FrameMonitor : Choreographer.FrameCallback {
    private var lastFrameTime = 0L
    private val frameInterval = 1000L / 60 // 16ms/帧

    override fun doFrame(frameTimeNanos: Long) {
        val currentTime = System.currentTimeMillis()
        if (lastFrameTime > 0) {
            val duration = currentTime - lastFrameTime
            if (duration > frameInterval * 2) {
                Log.w("FrameDrop", "丢帧 detected: ${duration - frameInterval}ms")
            }
        }
        lastFrameTime = currentTime
        Choreographer.getInstance().postFrameCallback(this)
    }
}

// 在Application中启动
Choreographer.getInstance().postFrameCallback(FrameMonitor())

object AppInitManager {
    private val ioDispatcher = Dispatchers.IO.limitedParallelism(4)
    private val tasks = mutableListOf<InitTask>()

    fun addTask(task: InitTask) {
        tasks.add(task)
    }

    fun start(scope: CoroutineScope) {
        tasks.map { task ->
            scope.launch(ioDispatcher) {
                val start = SystemClock.uptimeMillis()
                task.execute()
                Log.d("InitTask", "${task.name} took ${SystemClock.uptimeMillis() - start}ms")
            }
        }
    }
}

// 任务定义
abstract class InitTask(val name: String) {
    abstract fun execute()
}

@Composable
fun UserProfile(user: User) {
    Column {
        // 使用derivedStateOf减少重组
        val username by remember { derivedStateOf { user.name.uppercase() } }
        Text(text = username, modifier = Modifier.clickable { /*...*/ })

        // 使用key控制列表项重组
        LazyColumn {
            items(users, key = { it.id }) { user ->
                UserItem(user)
            }
        }
    }
}

@Composable
fun LargeList(items: List<Item>) {
    LazyColumn {
        itemsIndexed(
            items = items,
            key = { _, item -> item.id } // 关键：设置唯一key
        ) { index, item ->
            if (index % 50 == 0) {
                // 每50项添加一个StickyHeader
                stickyHeader { SectionHeader(item.category) }
            }
            ItemRow(item)
        }
    }
}