media3-compose-utils/CurrentMediaItemState.kt at main · at-oliverapps/media3-compose-utils · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
package io.oliverapps.radio.player.state

import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.*
import androidx.media3.common.MediaItem
import androidx.media3.common.MediaMetadata
import androidx.media3.common.Player
import androidx.media3.common.listen
import androidx.media3.common.util.UnstableApi

//use the new androidx.media3.ui.compose.state.rememberCurrentMediaItemState instead
//see https://github.com/at-oliverapps/media3-compose-utils/blob/main/Media3ComposeSample/mobile/src/main/java/io/oliverapps/sample/media3/compose/MIniPlayer.kt for usecases

/*
@UnstableApi
@Composable
fun rememberCurrentMediaItemState(player: Player): CurrentMediaItemState {
    val currentMediaItemState = remember(player) { CurrentMediaItemState(player) }
    LaunchedEffect(player) { currentMediaItemState.observe() }
    return currentMediaItemState
}

@UnstableApi
class CurrentMediaItemState(private val player: Player) {

    var mediaId: String by mutableStateOf(MediaItem.DEFAULT_MEDIA_ID)
        private set
    var mediaMetadata: MediaMetadata by mutableStateOf(MediaMetadata.EMPTY)
        private set
    var requestMetadata: MediaItem.RequestMetadata by mutableStateOf(MediaItem.RequestMetadata.EMPTY)
        private set
    var liveConfiguration: MediaItem.LiveConfiguration by mutableStateOf(MediaItem.LiveConfiguration.UNSET)
        private set
    var clippingConfiguration: MediaItem.ClippingConfiguration by mutableStateOf(MediaItem.ClippingConfiguration.UNSET)
        private set
    var localConfiguration: MediaItem.LocalConfiguration? by mutableStateOf(null) // Officially Nullable
        private set

    suspend fun observe(): Nothing {

        fun updateState(player: Player){
            player.currentMediaItem?.mediaMetadata?.let {
                mediaMetadata = it
            }

            player.currentMediaItem?.mediaId?.let {
                mediaId = it
            }

            player.currentMediaItem?.requestMetadata?.let {
                requestMetadata = it
            }

            player.currentMediaItem?.liveConfiguration?.let {
                liveConfiguration = it
            }

            player.currentMediaItem?.clippingConfiguration?.let {
                clippingConfiguration = it
            }

            localConfiguration = player.currentMediaItem?.localConfiguration
        }

        updateState(player)

        player.listen { events ->
            if (events.containsAny(Player.EVENT_MEDIA_ITEM_TRANSITION)) {
                updateState(this)
            }
        }

    }

}
/**
 * A Composable that provides the raw MediaItem. It is simpler to use but
 * may trigger wider recompositions than the granular state holder.
 *
 * use like
 * val currentMediaItem by rememberCurrentMediaItem(player)
 */
@UnstableApi
@Composable
fun rememberCurrentMediaItem(player: Player): State<MediaItem?> {
    val state = remember(player) { CurrentMediaItem(player) }
    LaunchedEffect(player) { state.observe() }
    return state.mediaItem
}

@UnstableApi
private class CurrentMediaItem(private val player: Player) {

    var mediaItem = mutableStateOf(player.currentMediaItem)
        private set

    suspend fun observe(): Nothing {

        mediaItem.value = player.currentMediaItem

        player.listen { events ->
            if (events.containsAny(Player.EVENT_MEDIA_ITEM_TRANSITION)) {
                mediaItem.value = this.currentMediaItem
            }
        }
    }
}
*/