0Pricing
Elixir & Phoenix: Scalable Backend Development · Aula

Presença e Atualizações de Dados em Tempo Real

Adicione o acompanhamento de presença às suas aplicações e gerencie atualizações de dados em tempo real para interfaces de usuário dinâmicas.

Presença e Atualizações de Dados em Tempo Real é uma aula grátis de Elixir & Phoenix: Scalable Backend Development no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Elixir & Phoenix: Scalable Backend Development, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Elixir & Phoenix: Scalable Backend Development inclui 4 aulas no total.

Partes desta aula ainda não foram traduzidas e aparecem em inglês.

What is User Presence?

In real-time applications, presence refers to tracking who is currently online, active, or viewing a specific resource.

  • Think of a chat application showing 'online' status.
  • Or a collaborative document editor indicating who else is viewing or editing.
  • It's crucial for dynamic, interactive user interfaces.

Phoenix.Presence Explained

Phoenix Framework provides a powerful, built-in module called Phoenix.Presence to manage presence information.

  • It leverages Elixir's concurrency and distribution features.
  • It automatically handles users joining, leaving, and even network disconnections.
  • This makes building robust presence features much simpler.

Integrating Presence in Channels

To use Phoenix.Presence, you typically integrate it into your Phoenix Channel modules.

First, ensure your UserSocket defines a pubsub_server (e.g., MyApp.PubSub). Then, within your channel module, you add use Phoenix.Presence.

This mixin provides helpers for tracking and retrieving presence data.

Tracking Users with `track/3`

The core function for adding a user to presence is Phoenix.Presence.track/3.

  • It takes the socket, a unique key (e.g., user ID), and metadata (e.g., username, status).
  • You usually call this in your channel's join/3 callback.
  • When a user joins a channel, they are tracked; when they leave, their presence is automatically removed.

Example: Basic Presence Track

Let's see how track/3 is called when a user joins a channel. We'll simulate a socket for this example.

defmodule MyRoomChannel do
  use Phoenix.Channel
  use Phoenix.Presence

  @impl true
  def join("room:lobby", _payload, socket) do
    # In a real app, user_id would come from auth
    user_id = "user_#{System.unique_integer([:positive])}"
    metadata = %{username: "Guest_#{user_id}", status: "online"}

    # Track the user's presence for this topic
    Phoenix.Presence.track(socket, user_id, metadata)
    IO.puts "User #{user_id} joined and tracked in room:lobby"
    {:ok, socket}
  end

  # Minimal run_example to simulate join
  def run_example do
    mock_socket = %{topic: "room:lobby", assigns: %{}}
    join("room:lobby", %{}, mock_socket)
  end
end

MyRoomChannel.run_example()

Accessing Presence Information

Once users are tracked, you can retrieve their presence information:

  • Phoenix.Presence.list(socket): Returns a map of all presences for the channel's topic.
  • Phoenix.Presence.get_by_key(socket, user_key): Retrieves presence data for a specific user key.

These functions allow you to build dynamic UI elements based on who is online.

Live Data Updates Concept

Beyond just knowing who is online, real-time apps often need to push live data updates to clients.

  • This could be a new chat message, a score update in a game, or a change in a shared item's status.
  • The key is to send structured data to all connected clients on a specific channel topic.
  • Clients then receive this data and update their UI accordingly.

Broadcasting Data with `broadcast!`

You can send live data updates using the broadcast!/3 function (or push/3 for direct messages) from your channel or another process.

  • broadcast!(socket, "event_name", %{data: "payload"}): Sends an event and payload to all clients subscribed to the socket's topic.
  • The "event_name" helps clients differentiate between types of updates.

This is how you keep all connected clients in sync with server-side changes.

Example: Broadcasting Live Data

Here's how you might broadcast a new message to all clients in a room. We simulate the broadcast call.

defmodule MyDataUpdater do
  # We use Phoenix.Channel for its broadcast! helper
  use Phoenix.Channel

  # Function to simulate sending an update
  def send_new_message(topic, sender, text) do
    event = "new_message"
    payload = %{sender: sender, text: text, timestamp: System.system_time(:second)}

    # In a real app, you'd call broadcast! from a channel context
    # or use Phoenix.PubSub.broadcast from a GenServer.
    # For this runnable example, we'll just demonstrate the payload.
    IO.puts "Simulating broadcast to '#{topic}' with event '#{event}' and payload:"
    IO.inspect payload
    :ok
  end

  # To run this example
  def run_example do
    send_new_message("room:lobby", "Alice", "Hello everyone!")
  end
end

MyDataUpdater.run_example()

Presence & Updates Check

Which of the following statements about Phoenix.Presence and live data updates are TRUE?

Summary: Presence & Live Data

Great job! You've learned how Phoenix.Presence simplifies tracking user activity in real-time applications.

  • We covered using Phoenix.Presence.track/3 to mark users as present.
  • You also saw how to retrieve presence information with list/1 and get_by_key/2.
  • Finally, we explored sending dynamic live data updates to clients using broadcast!/3 for interactive UIs.

These tools are fundamental for building engaging real-time features!

Perguntas Frequentes

A aula “Presença e Atualizações de Dados em Tempo Real” é grátis?

Sim — o texto completo de “Presença e Atualizações de Dados em Tempo Real” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Elixir & Phoenix: Scalable Backend Development, atualize para CoddyKit PRO. O curso de Elixir & Phoenix: Scalable Backend Development inclui 4 aulas no total.

O que vou aprender em “Presença e Atualizações de Dados em Tempo Real”?

Adicione o acompanhamento de presença às suas aplicações e gerencie atualizações de dados em tempo real para interfaces de usuário dinâmicas. Você pratica Elixir & Phoenix: Scalable Backend Development com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Elixir & Phoenix: Scalable Backend Development?

Nenhuma experiência prévia é necessária. Elixir & Phoenix: Scalable Backend Development no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Presença e Atualizações de Dados em Tempo Real”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Elixir & Phoenix: Scalable Backend Development?

Sim. Cada aula de Elixir & Phoenix: Scalable Backend Development inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Introdução aos Phoenix Channels
  2. Transmissão e Mensagens Pub/Sub
  3. Presença e Atualizações de Dados em Tempo Real
  4. Autenticação e Autorização de Channels
← Voltar para Elixir & Phoenix: Scalable Backend Development