Kotlin: Subscribe to channel

Subscribe to realtime changes in your database.

• Realtime is disabled by default for new Projects for better database performance and security. You can turn it on by managing replication.
• If you want to receive the "previous" data for updates and deletes, you will need to set REPLICA IDENTITY to FULL, like this: ALTER TABLE your_table REPLICA IDENTITY FULL;
• When using a method with a generic type like track, broadcast or broadcastFlow, you have to provide a serializable class as the type parameter.

Examples

Connect to Realtime

supabase.realtime.connect()

Listen to broadcasts

@Serializable
data class Message(val content: String, val sender: String)

val channel = supabase.realtime.createChannel("channelId") \{
    //optional config
\}

val broadcastFlow = channel.broadcastFlow<Message>(event = "message")

//in a new coroutine (or use Flow.onEach().launchIn(scope)):
broadcastFlow.collect \{ //it: Message
    println(it)
\}

supabase.realtime.connect()
channel.join(blockUntilJoined = true)

channel.broadcast(event = "message", Message("I joined!", "John"))

Listen to presence updates

@Serializable
data class PresenceState(val username: String)

val connectedUsers = mutableSetOf<PresenceState>()
val channel = supabase.realtime.createChannel("channelId") \{
    //optional config
\}

val presenceChangeFlow = channel.presenceChangeFlow()

//in a new coroutine (or use Flow.onEach().launchIn(scope)):
presenceChangeFlow.collect \{
    connectedUsers += it.decodeJoinsAs<PresenceState>()
    connectedUsers -= it.decodeLeavesAs<PresenceState>()
\}

supabase.realtime.connect()
channel.join(blockUntilJoined = true)
//send own state
channel.track(PresenceState(username = "John"))

Listen to all database changes

val channel = supabase.realtime.createChannel("channelId") \{
    //optional config
\}
val changeFlow = channel.postgresChangeFlow<PostgresAction>(schema = "public")

//in a new coroutine (or use Flow.onEach().launchIn(scope)):
changeFlow.collect \{
    when(it) \{
        is PostgresAction.Delete -> println("Deleted: $\{it.oldRecord\}")
        is PostgresAction.Insert -> println("Inserted: $\{it.record\}")
        is PostgresAction.Select -> println("Selected: $\{it.record\}")
        is PostgresAction.Update -> println("Updated: $\{it.oldRecord\} with $\{it.record\}")
    \}
\}

supabase.realtime.connect()
channel.join()

Listen to a specific table

val channel = supabase.realtime.createChannel("channelId") \{
    //optional config
\}
val changeFlow = channel.postgresChangeFlow<PostgresAction>(schema = "public") \{
    table = "users"
\}

//in a new coroutine (or use Flow.onEach().launchIn(scope)):
changeFlow.collect \{
    when(it) \{
        is PostgresAction.Delete -> println("Deleted: $\{it.oldRecord\}")
        is PostgresAction.Insert -> println("Inserted: $\{it.record\}")
        is PostgresAction.Select -> println("Selected: $\{it.record\}")
        is PostgresAction.Update -> println("Updated: $\{it.oldRecord\} with $\{it.record\}")
    \}
\}

supabase.realtime.connect()
channel.join()

Listen to inserts

val channel = supabase.realtime.createChannel("channelId") \{
    //optional config
\}
val changeFlow = channel.postgresChangeFlow<PostgresAction.Insert>(schema = "public") \{
    table = "users"
\}

//in a new coroutine (or use Flow.onEach().launchIn(scope)):
changeFlow.collect \{
    println(it.record)
\}

supabase.realtime.connect()
channel.join()

Listen to updates

val channel = supabase.realtime.createChannel("channelId") \{
    //optional config
\}
val changeFlow = channel.postgresChangeFlow<PostgresAction.Update>(schema = "public") \{
    table = "users"
\}

//in a new coroutine (or use Flow.onEach().launchIn(scope)):
changeFlow.collect \{
    println(it.record)
    println(it.oldRecord)
\}

supabase.realtime.connect()
channel.join()

Listen to deletes

val channel = supabase.realtime.createChannel("channelId") \{
    //optional config
\}
val changeFlow = channel.postgresChangeFlow<PostgresAction.Delete>(schema = "public") \{
    table = "users"
\}

//in a new coroutine (or use Flow.onEach().launchIn(scope)):
changeFlow.collect \{
    println(it.oldRecord)
\}

supabase.realtime.connect()
channel.join()

Listen to row level changes

val channel = supabase.realtime.createChannel("channelId") \{
   //optional config
\}
val changeFlow = channel.postgresChangeFlow<PostgresAction.Delete>(schema = "public") \{
    table = "users"
    filter = "id=eq.1"
\}

//in a new coroutine:
changeFlow.collect \{
    println(it.oldRecord)
\}

supabase.realtime.connect()
channel.join()