如何让Jetpack Compose的LaunchedEffect仅在Track变更时触发？

问题原因分析 #

当前你的LaunchedEffect会在uiState任意字段变化时触发，核心原因可能有两个：

1. Track的equals逻辑不准确：Track数据类包含Bitmap类型的thumbnail字段，而Bitmap默认的equals是比较对象引用而非内容。即使是同一首歌的封面，每次从数据库/文件加载时可能生成新的Bitmap实例，导致Track的equals返回false，被LaunchedEffect判定为“新对象”。
2. ViewModel的combine逻辑导致Track实例重复生成：每次progressFlow、playbackStateFlow等非Track相关的Flow更新时，都会创建新的TrackLoaded实例。如果nowPlayingFlow每次返回的nowPlaying.track是新实例（比如数据库查询每次返回新对象），即使内容相同，也可能因Bitmap的引用问题被判定为不同。

解决方案 #

方案1：修正Track的equals和hashCode逻辑 #

忽略thumbnail字段的比较（因为封面变化不代表Track本身变更），重写Track的equals和hashCode：

@Entity
data class Track(
    @PrimaryKey(autoGenerate = false)
    val trackId: Long,
    val trackTitle: String,
    val trackLength: Int,
    val artist: String,
    val albumId: Long,
    val contentUri: Uri?,
    @Ignore // 数据库无需存储Bitmap，避免序列化问题
    val thumbnail: Bitmap? = null,
    val mimeType: String?,
    val hasThumbnail: Boolean
) {
    override fun equals(other: Any?): Boolean {
        if (this === other) return true
        if (javaClass != other?.javaClass) return false

        other as Track

        if (trackId != other.trackId) return false
        if (trackTitle != other.trackTitle) return false
        if (trackLength != other.trackLength) return false
        if (artist != other.artist) return false
        if (albumId != other.albumId) return false
        if (contentUri != other.contentUri) return false
        if (mimeType != other.mimeType) return false
        if (hasThumbnail != other.hasThumbnail) return false

        // 跳过thumbnail的比较
        return true
    }

    override fun hashCode(): Int {
        var result = trackId.hashCode()
        result = 31 * result + trackTitle.hashCode()
        result = 31 * result + trackLength
        result = 31 * result + artist.hashCode()
        result = 31 * result + albumId.hashCode()
        result = 31 * result + (contentUri?.hashCode() ?: 0)
        result = 31 * result + (mimeType?.hashCode() ?: 0)
        result = 31 * result + hasThumbnail.hashCode()
        
        // 跳过thumbnail的hash计算
        return result
    }
}

方案2：使用Track的唯一标识作为LaunchedEffect的key #

直接用trackId作为key（因为trackId是Track的唯一主键，能准确标识Track是否变更），无需依赖Track的equals逻辑：

@Composable
fun NowPlayingScreen(
    uiState: NowPlayingState.TrackLoaded,
    nowPlayingViewModel: NowPlayingViewModel,
    goBack: () -> Unit
) {
    val (track, isPlaying, repeatMode, isShuffleActive, progress, playbackState) = uiState
  
    // 用trackId作为key，确保只有Track本身切换时触发
    LaunchedEffect(key1 = track.trackId) {
        Timber.d("LAUNCHED EFFECT")
    }
}

方案3：拆分ViewModel的状态流 #

将Track状态与播放控制状态（进度、播放状态等）分离，避免非Track字段更新影响Track的判定：

class NowPlayingViewModel @Inject constructor(
    private val audioRepository: AudioRepository,
) : ViewModel() {
    private val errorFlow = MutableStateFlow<PlaybackException?>(null)
    private val progressFlow = MutableStateFlow(0L)
    private val playbackStateFlow = MutableStateFlow(-1)
    private val nowPlayingFlow = audioRepository.getNowPlayingFlow()

    // 单独暴露当前Track的Flow，仅在Track变更时发射新值
    val currentTrack = nowPlayingFlow
        .map { it?.track }
        .distinctUntilChanged() // 确保只有Track真正变化时才更新
        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), null)

    // 单独暴露播放控制状态Flow
    val playbackControls = combine(
        nowPlayingFlow,
        progressFlow,
        playbackStateFlow,
        errorFlow
    ) { nowPlaying, progress, playbackState, exception ->
        nowPlaying?.let {
            PlaybackControlsState(
                isPlaying = it.isPlaying,
                repeatMode = it.repeatMode,
                shuffleActive = it.shuffleActive,
                progress = progress,
                playbackState = playbackState
            )
        } ?: exception?.let {
            NowPlayingState.ErrorLoadingTrack(Result.Error(it.localizedMessage ?: ""))
        } ?: NowPlayingState.Loading
    }.stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), NowPlayingState.Loading)
}

// 新增播放控制状态数据类
data class PlaybackControlsState(
    val isPlaying: Boolean,
    val repeatMode: Int,
    val shuffleActive: Boolean,
    val progress: Long,
    val playbackState: Int
)

在Composable中分别收集两个状态：

@Composable
fun NowPlayingScreen(
    currentTrack: Track?,
    playbackControls: Any?, // 根据实际状态类型调整
    nowPlayingViewModel: NowPlayingViewModel,
    goBack: () -> Unit
) {
    currentTrack?.let { track ->
        LaunchedEffect(key1 = track) {
            Timber.d("LAUNCHED EFFECT")
        }
    }

    // 处理播放控制状态和界面渲染
}

内容的提问来源于stack exchange，提问作者Bajomo Richard