Build your first App using Phoenix LiveView
and understand all the concepts in 20 minutes or less!
- Phoenix LiveView Counter Tutorial
- Why? 🤷
- What? 💭
- Who? 👤
- How? 💻
- Congratulations! 🎉
- Future Steps
There are several example apps around the Internet using Phoenix LiveView but none include step-by-step instructions a complete beginner can follow. This is the complete beginner's tutorial we wish we had when learning LiveView and the one you have been searching for! 🎉
A complete beginners tutorial for building the most basic possible Phoenix LiveView App with no prior experience necessary.
Phoenix LiveView allows you to build rich interactive web apps
with realtime reactive UI (no page refresh when data updates)
without writing JavaScript!
This enables building incredible user experiences
with considerably less code.
LiveView pages load instantly because they are rendered on the Server
and they require far less bandwidth than a similar
React, Vue.js, Angular, etc. because only the bare minimum
is loaded on the client for the page to work.
For a sneak peak of what is possible to build with LiveView,
watch @chrismccord's LiveBeats intro:
Phoenix.LiveView.LiveBeats.Demo.mp4
Tip: Enable the sound. It's a collaborative music listening experience. 🎶
See: https://github.com/phoenixframework/phoenix_live_view
This tutorial is aimed at people who have
never built anything in Phoenix or LiveView.
You can speed-run it in 10 minutes
if you're already familiar with Phoenix or Rails.
If you get stuck at any point while following the tutorial or you have any feedback/questions, please open an issue on GitHub!
If you don't have a lot of time or bandwidth to watch videos,
this tutorial will be the fastest way to learn LiveView.
Before you start working through the tutorial, you will need:
a. Elixir installed on your computer.
See: learn-elixir#installation
When you run the command:
elixir -vYou should expect to see output similar to the following:
Elixir 1.14.2 (compiled with Erlang/OTP 25)This informs us we are using Elixir version 1.14.2
which is the latest version at the time of writing.
Some of the more advanced features of Phoenix 1.7 during compilation time require elixir
1.14 although the code will work in previous versions.
b. Phoenix installed on your computer.
see: hexdocs.pm/phoenix/installation
If you run the following command in your terminal:
mix phx.new -vYou should see something similar to the following:
Phoenix installer v1.7.0-rc.0If you have an earlier version,
definitely upgrade to get the latest features!
If you have a later version of Phoenix,
and you get stuck at any point,
please
open an issue on GitHub!
We are here to help!
c. Basic familiarity with Elixir syntax
is recommended but not essential;
If you know any programming language,
you can pick it up as you go and
ask questions
if you get stuck!
See: https://github.com/dwyl/learn-elixir
This tutorial takes you through all the steps
to build and test a counter in Phoenix LiveView.
We always
"begin with the end in mind"
so we recommend running the finished app
on your machine before writing any code.
💡 You can also try the version deployed to Heroku: https://live-view-counter.herokuapp.com
Before you attempt to build the counter,
we suggest that you clone and run
the complete app on your localhost.
That way you know it's working
without much effort/time expended.
On your localhost,
run the following command to clone the repo
and change into the directory:
git clone https://github.com/dwyl/phoenix-liveview-counter-tutorial.git
cd phoenix-liveview-counter-tutorialInstall the dependencies by running the command:
mix setupIt will take a few seconds to download the dependencies depending on the speed of your internet connection; be patient. 😉
Start the Phoenix server by running the command:
mix phx.serverNow you can visit
localhost:4000
in your web browser.
💡 Open a second browser window (e.g. incognito mode), you will see the the counter updating in both places like magic!
You should expect to see:
With the finished version of the App running on your machine and a clear picture of where we are headed, it's time to build it!
In your terminal run the following mix command
to generate the new Phoenix app:
mix phx.new live_view_counter --no-ectoThe --no-ecto flag tells mix phx.new
to create an App without a Database.
This keeps our counter as simple as possible.
We can always add a Database later.
Note: Since
Phoenix1.6the--liveflag is no longer required when creating aLiveViewapp.LiveViewis included by default in all newPhoenixApps. Older tutorials may still include the flag, everything is much easier now.
When you see the following prompt:
Fetch and install dependencies? [Yn]Type Y followed by the [Enter] key.
That will download all the necessary dependencies.
In your terminal, go into the newly created app folder using:
cd live_view_counterAnd then run the following mix command:
mix testThe first time it will compile Phoenix and will take some time. You should see something similar to this:
Compiling 17 files (.ex)
Generated live_view_counter app
.....
Finished in 0.1 seconds (0.05s async, 0.1s sync)
5 tests, 0 failures
Tests all pass. This is expected with a new app. It's a good way to confirm everything is working.
Run the server by executing this command:
mix phx.serverVisit
localhost:4000
in your web browser.
Create a new file with the path:
lib/live_view_counter_web/live/counter.ex
And add the following code to it:
defmodule LiveViewCounterWeb.Counter do
use LiveViewCounterWeb, :live_view
def mount(_params, _session, socket) do
{:ok, assign(socket, :val, 0)}
end
def handle_event("inc", _, socket) do
{:noreply, update(socket, :val, &(&1 + 1))}
end
def handle_event("dec", _, socket) do
{:noreply, update(socket, :val, &(&1 - 1))}
end
def render(assigns) do
~H"""
<div>
<h1 class="text-4xl font-bold text-center"> The count is: <%= @val %> </h1>
<p class="text-center">
<.button phx-click="dec">-</.button>
<.button phx-click="inc">+</.button>
</p>
</div>
"""
end
endThe first line instructs Phoenix to use the Phoenix.LiveView behaviour.
This just means that we will need to implement certain functions
for our live view to work.
The first function is mount/3 which,
as it's name suggests, mounts the module
with the _params, _session and socket arguments:
def mount(_params, _session, socket) do
{:ok, assign(socket, :val, 0) }
endIn our case we are ignoring the _params and _session,
hence the underscore prepended
to the parameters.
If we were using sessions for user management,
we would need to check the session variable,
but in this simple counter example we just ignore it.
mount/3 returns a
tuple:
{:ok, assign(socket, :val, 0)}
which uses the
assign/3
function to assign the :val key a value of 0 on the socket.
That just means the socket will now have a :val
which is initialised to 0.
The second function is handle_event/3
which handles the incoming events received.
In the case of the first declaration of
handle_event("inc", _, socket)
it pattern matches the string "inc"
and increments the counter.
def handle_event("inc", _, socket) do
{:noreply, update(socket, :val, &(&1 + 1))}
endhandle_event/3 ("inc")
returns a tuple of:
{:noreply, update(socket, :val, &(&1 + 1))}
where the :noreply just means
"do not send any further messages to the caller of this function".
update(socket, :val, &(&1 + 1)) as it's name suggests,
will update the value of :val on the socket
to the
&(&1 + 1) is a shorthand way of writing fn val -> val + 1 end.
the &() is the same as fn ... end
(where the ... is the function definition).
If this inline anonymous function syntax is unfamiliar to you,
please read:
https://elixir-lang.org/crash-course.html#partials-and-function-captures-in-elixir
The third function is almost identical to the one above,
the key difference is that it decrements the :val.
def handle_event("dec", _, socket) do
{:noreply, update(socket, :val, &(&1 - 1))}
endhandle_event("dec", _, socket) pattern matches the "dec" String
and decrements the counter using the &(&1 - 1) syntax.
In
Elixirwe can have multiple similar functions with the same function name but different matches on the arguments or different "arity" (number of arguments).
For more detail on Functions in Elixir, see: https://elixirschool.com/en/lessons/basics/functions/#named-functions
Finally the forth function render/1
receives the assigns argument which contains the :val state
and renders the template using the @val template variable.
The render/1 function renders the template included in the function.
The ~H""" syntax just means
"treat this multiline string as a LiveView template"
The ~H sigil
is a macro included when the use Phoenix.LiveView is invoked
at the top of the file.
LiveView will invoke the mount/3 function
and will pass the result of mount/3 to render/1 behind the scenes.
Each time an update happens (e.g: handle_event/3)
the render/1 function will be executed
and updated data (in our case the :val count)
is sent to the client.
🏁 At the end of Step 2 you should have a file similar to:
lib/live_view_counter_web/live/counter.ex
Now that we have created our Live handler function in Step 2, it's time to tell Phoenix how to invoke it.
Open the
lib/live_view_counter_web/router.ex
file and locate the block of code
that starts with scope "/", LiveViewCounterWeb do:
scope "/", LiveViewCounterWeb do
pipe_through :browser
get "/", PageController, :index
endReplace the line get "/", PageController, :index
with live("/", Counter).
So you end up with:
scope "/", LiveViewCounterWeb do
pipe_through :browser
live("/", Counter)
endSince we have replaced the
get "/", PageController, :index route in router.ex
in the previous step, the test in
test/live_view_counter_web/controllers/page_controller_test.exs
will now fail:
Compiling 6 files (.ex)
Generated live_view_counter app
....
1) test GET / (LiveViewCounterWeb.PageControllerTest)
test/live_view_counter_web/controllers/page_controller_test.exs:4
Assertion with =~ failed
code: assert html_response(conn, 200) =~ "Peace of mind from prototype to production"
left: "<!DOCTYPE html>\n<html lang=\"en\">\n <head>\n <meta charset=\"utf-8\">\n <meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">\n <meta name=\"csrf-token\" content=\"EFt5PABkPz1nPg5FMAoaDSA6BCFtBCMO_4JmNTx_2vO6i3qxXjETTpal\">\n <title data-suffix=\" · Phoenix Framework\">\nLiveViewCounter\n · Phoenix Framework</title>\n <link phx-track-static rel=\"stylesheet\" href=\"/assets/app.css\">\n <script defer phx-track-static type=\"text/javascript\" src=\"/assets/app.js\">\n </script>\n </head>\n <body class=\"bg-white antialiased\">\n<div data-phx-main=\"true\" data-phx-session=\"SFMyNTY.g2gDaAJhBXQAAAAIZAACaWRtAAAAFHBoeC1GeWkzSUNDYTd2UHFEQURFZAAMbGl2ZV9zZXNzaW9uaAJkAAdkZWZhdWx0bggAuNQjZx-3KBdkAApwYXJlbnRfcGlkZAADbmlsZAAIcm9vdF9waWRkAANuaWxkAAlyb290X3ZpZXdkACFFbGl4aXIuTGl2ZVZpZXdDb3VudGVyV2ViLkNvdW50ZXJkAAZyb3V0ZXJkACBFbGl4aXIuTGl2ZVZpZXdDb3VudGVyV2ViLlJvdXRlcmQAB3Nlc3Npb250AAAAAGQABHZpZXdkACFFbGl4aXIuTGl2ZVZpZXdDb3VudGVyV2ViLkNvdW50ZXJuBgB-d1aLhAFiAAFRgA.hdT9WuJRfJeX-TckMFWrkUEVEh_orieA_DkMToWk-7Q\" data-phx-static=\"SFMyNTY.g2gDaAJhBXQAAAADZAAKYXNzaWduX25ld2pkAAVmbGFzaHQAAAAAZAACaWRtAAAAFHBoeC1GeWkzSUNDYTd2UHFEQURFbgYAjXdWi4QBYgABUYA.6RULnUMCLG3q5DBgBuTc-2ZP2L0jyu-DoIHLG7WlEDs\" id=\"phx-Fyi3ICCa7vPqDADE\"><header class=\"px-4 sm:px-6 lg:px-8\">\n <div class=\"flex items-center justify-between border-b border-zinc-100 py-3\">\n <div class=\"flex items-center gap-4\">\n <a href=\"/\">\n <svg viewBox=\"0 0 71 48\" class=\"h-6\" aria-hidden=\"true\">\n <path d=\"m26.371 33.477-.552-.1c-3.92-.729-6.397-3.1-7.57-6.829-.733-2.324.597-4.035 3.035-4.148 1.995-.092 3.362 1.055 4.57 2.39 1.557 1.72 2.984 3.558 4.514 5.305 2.202 2.515 4.797 4.134 8.347 3.634 3.183-.448 5.958-1.725 8.371-3.828.363-.316.761-.592 1.144-.886l-.241-.284c-2.027.63-4.093.841-6.205.735-3.195-.16-6.24-.828-8.964-2.582-2.486-1.601-4.319-3.746-5.19-6.611-.704-2.315.736-3.934 3.135-3.6.948.133 1.746.56 2.463 1.165.583.493 1.143 1.015 1.738 1.493 2.8 2.25 6.712 2.375 10.265-.068-5.842-.026-9.817-3.24-13.308-7.313-1.366-1.594-2.7-3.216-4.095-4.785-2.698-3.036-5.692-5.71-9.79-6.623C12.8-.623 7.745.14 2.893 2.361 1.926 2.804.997 3.319 0 4.149c.494 0 .763.006 1.032 0 2.446-.064 4.28 1.023 5.602 3.024.962 1.457 1.415 3.104 1.761 4.798.513 2.515.247 5.078.544 7.605.761 6.494 4.08 11.026 10.26 13.346 2.267.852 4.591 1.135 7.172.555ZM10.751 3.852c-.976.246-1.756-.148-2.56-.962 1.377-.343 2.592-.476 3.897-.528-.107.848-.607 1.306-1.336 1.49Zm32.002 37.924c-.085-.626-.62-.901-1.04-1.228-1.857-1.446-4.03-1.958-6.333-2-1.375-.026-2.735-.128-4.031-.61-.595-.22-1.26-.505-1.244-1.272.015-.78.693-1 1.31-1.184.505-.15 1.026-.247 1.6-.382-1.46-.936-2.886-1.065-4.787-.3-2.993 1.202-5.943 1.06-8.926-.017-1.684-.608-3.179-1.563-4.735-2.408l-.043.03a2.96 2.96 0 0 0 .04-.029c-.038-.117-.107-.12-.197-.054l.122.107c1.29 2.115 3.034 3.817 5.004 5.271 3.793 2.8 7.936 4.471 12.784 3.73A66.714 66.714 0 0 1 37 40.877c1.98-.16 3.866.398 5.753.899Zm-9.14-30.345c-.105-.076-.206-.266-.42-.069 1.745 2.36 3.985 4.098 6.683 5.193 4.354 1.767 8.773 2.07 13.293.51 3.51-1.21 6.033-.028 7.343 3.38.19-3.955-2.137-6.837-5.843-7.401-2.084-.318-4.01.373-5.962.94-5.434 1.575-10.485.798-15.094-2.553Zm27.085 15.425c.708.059 1.416.123 2.124.185-1.6-1.405-3.55-1.517-5.523-1.404-3.003.17-5.167 1.903-7.14 3.972-1.739 1.824-3.31 3.87-5.903 4.604.043.078.054.117.066.117.35.005.699.021 1.047.005 3.768-.17 7.317-.965 10.14-3.7.89-.86 1.685-1.817 2.544-2.71.716-.746 1.584-1.159 2.645-1.07Zm-8.753-4.67c-2.812.246-5.254 1.409-7.548 2.943-1.766 1.18-3.654 1.738-5.776 1.37-.374-.066-.75-.114-1.124-.17l-.013.156c.135.07.265.151.405.207.354.14.702.308 1.07.395 4.083.971 7.992.474 11.516-1.803 2.221-1.435 4.521-1.707 7.013-1.336.252.038.503.083.756.107.234.022.479.255.795.003-2.179-1.574-4.526-2.096-7.094-1.872Zm-10.049-9.544c1.475.051 2.943-.142 4.486-1.059-.452.04-.643.04-.827.076-2.126.424-4.033-.04-5.733-1.383-.623-.493-1.257-.974-1.889-1.457-2.503-1.914-5.374-2.555-8.514-2.5.05.154.054.26.108.315 3.417 3.455 7.371 5.836 12.369 6.008Zm24.727 17.731c-2.114-2.097-4.952-2.367-7.578-.537 1.738.078 3.043.632 4.101 1.728.374.388.763.768 1.182 1.106 1.6 1.29 4.311 1.352 5.896.155-1.861-.726-1.861-.726-3.601-2.452Zm-21.058 16.06c-1.858-3.46-4.981-4.24-8.59-4.008a9.667 9.667 0 0 1 2.977 1.39c.84.586 1.547 1.311 2.243 2.055 1.38 1.473 3.534 2.376 4.962 2.07-.656-.412-1.238-.848-1.592-1.507Zm17.29-19.32c0-.023.001-.045.003-.068l-.006.006.006-.006-.036-.004.021.018.012.053Zm-20 14.744a7.61 7.61 0 0 0-.072-.041.127.127 0 0 0 .015.043c.005.008.038 0 .058-.002Zm-.072-.041-.008-.034-.008.01.008-.01-.022-.006.005.026.024.014Z\" fill=\"#FD4F00\"></path>\n </svg>\n </a>\n <p class=\"rounded-full bg-brand/5 px-2 text-[0.8125rem] font-medium leading-6 text-brand\">\n v1.7\n </p>\n </div>\n <div class=\"flex items-center gap-4\">\n <a href=\"https://twitter.com/elixirphoenix\" class=\"text-[0.8125rem] font-semibold leading-6 text-zinc-900 hover:text-zinc-700\">\n @elixirphoenix\n </a>\n <a href=\"https://github.com/phoenixframework/phoenix\" class=\"text-[0.8125rem] font-semibold leading-6 text-zinc-900 hover:text-zinc-700\">\n GitHub\n </a>\n <a href=\"https://hexdocs.pm/phoenix/overview.html\" class=\"rounded-lg bg-zinc-100 px-2 py-1 text-[0.8125rem] font-semibold leading-6 text-zinc-900 hover:bg-zinc-200/80 active:text-zinc-900/70\">\n Get Started <span aria-hidden=\"true\">→</span>\n </a>\n </div>\n </div>\n</header>\n<main class=\"px-4 py-20 sm:px-6 lg:px-8\">\n <div class=\"mx-auto max-w-2xl\">\n \n \n <div id=\"disconnected\" phx-click=\"[["push",{"event":"lv:clear-flash","value":{"key":"error"}}],["hide",{"time":200,"to":"#flash","transition":[["transition-all","transform","ease-in","duration-200"],["opacity-100","translate-y-0","sm:scale-100"],["opacity-0","translate-y-4","sm:translate-y-0","sm:scale-95"]]}]]\" role=\"alert\" class=\"fixed hidden top-2 right-2 w-80 sm:w-96 z-50 rounded-lg p-3 shadow-md shadow-zinc-900/5 ring-1 bg-rose-50 p-3 text-rose-900 shadow-md ring-rose-500 fill-rose-900\" phx-connected=\"[["hide",{"time":200,"to":"#disconnected","transition":[["transition-all","transform","ease-in","duration-200"],["opacity-100","translate-y-0","sm:scale-100"],["opacity-0","translate-y-4","sm:translate-y-0","sm:scale-95"]]}]]\" phx-disconnected=\"[["show",{"display":null,"time":200,"to":"#disconnected","transition":[["transition-all","transform","ease-out","duration-300"],["opacity-0","translate-y-4","sm:translate-y-0","sm:scale-95"],["opacity-100","translate-y-0","sm:scale-100"]]}]]\">\n <p class=\"flex items-center gap-1.5 text-[0.8125rem] font-semibold leading-6\">\n \n <svg xmlns=\"http://www.w3.org/2000/svg\" aria-hidden=\"true\" class=\"h-4 w-4\" fill=\"currentColor\" viewBox=\"0 0 20 20\">\n <path fill-rule=\"evenodd\" d=\"M18 10a8 8 0 11-16 0 8 8 0 0116 0zm-8-5a.75.75 0 01.75.75v4.5a.75.75 0 01-1.5 0v-4.5A.75.75 0 0110 5zm0 10a1 1 0 100-2 1 1 0 000 2z\" clip-rule=\"evenodd\"/>\n</svg>\n We can't find the internet\n </p>\n <p class=\"mt-2 text-[0.8125rem] leading-5\">\n Attempting to reconnect <svg xmlns=\"http://www.w3.org/2000/svg\" aria-hidden=\"true\" class=\"ml-1 w-3 h-3 inline animate-spin\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"1.5\" viewBox=\"0 0 24 24\">\n <path stroke-linecap=\"round\" stroke-linejoin=\"round\" d=\"M16.023 9.348h4.992v-.001M2.985 19.644v-4.992m0 0h4.992m-4.993 0l3.181 3.183a8.25 8.25 0 0013.803-3.7M4.031 9.865a8.25 8.25 0 0113.803-3.7l3.181 3.182m0-4.991v4.99\"/>\n</svg>\n </p>\n \n</div>\n<div>\n<h1 class=\"text-4xl font-bold text-center\"> The count is: 0 </h1>\n\n<p class=\"text-center\">\n <button class=\"phx-submit-loading:opacity-75 rounded-lg bg-zinc-900 hover:bg-zinc-700 py-2 px-3 text-sm font-semibold leading-6 text-white active:text-white/80 \" phx-click=\"dec\">\n -\n</button>\n <button class=\"phx-submit-loading:opacity-75 rounded-lg bg-zinc-900 hover:bg-zinc-700 py-2 px-3 text-sm font-semibold leading-6 text-white active:text-white/80 \" phx-click=\"inc\">\n +\n</button>\n </p>\n </div>\n </div>\n</main></div>\n </body>\n</html>"
right: "Peace of mind from prototype to production"
stacktrace:
test/live_view_counter_web/controllers/page_controller_test.exs:6: (test)
Finished in 0.1 seconds (0.06s async, 0.09s sync)
5 tests, 1 failureThis just tells us that the test is looking for the string
"Peace of mind from prototype to production" in the page and did not find it.
To fix the broken test, open the
test/live_view_counter_web/controllers/page_controller_test.exs
file and locate the line:
assert html_response(conn, 200) =~ "Peace of mind from prototype to production"Update the string from "Peace of mind from prototype to production"
to something we know is present on the page,
e.g:
"The count is"
🏁 The
page_controller_test.exs.exsfile should now look like this:test/live_view_counter_web/controllers/page_controller_test.exs#L6
Confirm the tests pass again by running:
mix testYou should see output similar to:
.....
Finished in 0.1 seconds (0.03s async, 0.07s sync)
5 tests, 0 failures
Randomized with seed 244388
Now that all the code for the counter.ex is written,
run the Phoenix app with the following command:
mix phx.server
Vist
localhost:4000
in your web browser.
You should expect to see a fully functioning LiveView counter:
Once the initial installation
and configuration of LiveView was complete,
the creation of the actual counter was remarkably simple.
We created a single new file
lib/live_view_counter_web/live/counter.ex
that contains all the code required to
initialise, render and update the counter.
Then we set the live "/", Counter route
to invoke the Counter module in router.ex.
In total our counter App is 25 lines of code.
One important thing to note is that the counter only maintains state for a single web browser. Try opening a second browser window (e.g: in "incognito mode") and notice how the counter only updates in one window at a time:
If we want to share the counter state between multiple clients, we need to add a bit more code.
One of the biggest selling points of using Phoenix to build web apps is the built-in support for WebSockets in the form of "channels". Phoenix Channels allow us to effortlessly sync data between clients and servers with minimal overhead.
We can share the counter state
between multiple clients by updating the
counter.ex
file with the following code:
defmodule LiveViewCounterWeb.Counter do
use LiveViewCounterWeb, :live_view
@topic "live"
def mount(_session, _params, socket) do
LiveViewCounterWeb.Endpoint.subscribe(@topic) # subscribe to the channel
{:ok, assign(socket, :val, 0)}
end
def handle_event("inc", _value, socket) do
new_state = update(socket, :val, &(&1 + 1))
LiveViewCounterWeb.Endpoint.broadcast_from(self(), @topic, "inc", new_state.assigns)
{:noreply, new_state}
end
def handle_event("dec", _, socket) do
new_state = update(socket, :val, &(&1 - 1))
LiveViewCounterWeb.Endpoint.broadcast_from(self(), @topic, "dec", new_state.assigns)
{:noreply, new_state}
end
def handle_info(msg, socket) do
{:noreply, assign(socket, val: msg.payload.val)}
end
def render(assigns) do
~H"""
<div>
<h1>The count is: <%= @val %></h1>
<.button phx-click="dec">-</.button>
<.button phx-click="inc">+</.button>
</div>
"""
end
endThe first change is on
Line 4
@topic "live" defines a module attribute
(think of it as a global constant),
that lets us to reference @topic anywhere in the file.
The second change is on
Line 7
where the
mount/3
function now creates a subscription to the topic:
LiveViewCounterWeb.Endpoint.subscribe(@topic) # subscribe to the channel topicEach client connected to the App
subscribes to the @topic
so when the count is updated on any of the clients,
all the other clients see the same value.
This uses Phoenix's built-in channels (WebSocket) system.
Next we update the first
handle_event/3
function which handles the "inc" event:
def handle_event("inc", _msg, socket) do
new_state = update(socket, :val, &(&1 + 1))
LiveViewCounterWeb.Endpoint.broadcast_from(self(), @topic, "inc", new_state.assigns)
{:noreply, new_state}
endAssign the result of the update invocation to new_state
so that we can use it on the next two lines.
Invoking
LiveViewCounterWeb.Endpoint.broadcast_from
sends a message from the current process self()
on the @topic, the key is "inc"
and the value is the new_state.assigns Map.
In case you are curious (like we are),
new_state is an instance of the
Phoenix.LiveView.Socket
socket:
#Phoenix.LiveView.Socket<
assigns: %{
flash: %{},
live_view_action: nil,
live_view_module: LiveViewCounterWeb.Counter,
val: 1
},
changed: %{val: true},
endpoint: LiveViewCounterWeb.Endpoint,
id: "phx-Ffq41_T8jTC_3gED",
parent_pid: nil,
view: LiveViewCounterWeb.Counter,
...
}The new_state.assigns is a Map
that includes the key val
where the value is 1
(after we clicked on the increment button).
The fourth update is to the
"dec" version of
handle_event/3
def handle_event("dec", _msg, socket) do
new_state = update(socket, :val, &(&1 - 1))
LiveViewCounterWeb.Endpoint.broadcast_from(self(), @topic, "dec", new_state.assigns)
{:noreply, new_state}
endThe only difference from the "inc"
version is the &(&1 - 1)
and "dec" in the broadcast_from.
The final change is the implementation of the handle_info/2 function:
def handle_info(msg, socket) do
{:noreply, assign(socket, val: msg.payload.val)}
endhandle_info/2
handles Elixir process messages
where msg is the received message
and socket is the Phoenix.Socket.
The line {:noreply, assign(socket, val: msg.payload.val)}
just means "don't send this message to the socket again"
(which would cause a recursive loop of updates).
🏁 At the end of Step 6 the file looks like:
lib/live_view_counter_web/live/counter.ex
Now that
counter.ex
has been updated to broadcast the count to all connected clients,
let's run the app in a few web browsers to show it in action!
In your terminal, run:
mix phx.server
Open
localhost:4000
in as many web browsers as you have
and test the increment/decrement buttons!
You should see the count increasing/decreasing in all browsers simultaneously!
You just built a real-time counter that seamlessly updates all connected clients using Phoenix LiveView in less than 40 lines of code!
That's it for this tutorial.
We hope you enjoyed learning with us!
If you found this useful, please ⭐️ and share the GitHub repo
so we know you like it!
If you've enjoyed this basic counter tutorial
and want something a bit more advanced,
checkout our LiveView Chat Tutorial:
github.com/dwyl/phoenix-liveview-chat-example
Several people in the Elixir / Phoenix community
have found this tutorial helpful when starting to use LiveView,
e.g: Kurt Mackey @mrkurt
twitter.com/mrkurt/status/1362940036795219973
He deployed the counter app to a 17 region cluster using fly.io: https://liveview-counter.fly.dev
Your feedback is always very much welcome! 🙏
With this implementation you may have noticed that when we open a new browser window the count is always zero. As soon as we click plus or minus it adjusts and all the views get back in line. This is because the state is replicated across LiveView instances and coordinated via pub-sub. If the state was big and complicated this would get wasteful in resources and hard to manage.
Generally it is good practice to identify shared state and to manage that in a single location.
The Elixir way of managing state is the GenServer, using PubSub to update the LiveViews about changes. This allows the LiveViews to focus on user specific state, separating concerns; making the application both more efficient (hopefully) and easier to reason about and debug.
We are now going to start making use of the lib/live_view_counter directory! The Phoenix docs says that this holds "all of your business domain". For us this is the current count, along with the incr and decr methods.
Create a file with the path lib/live_view_counter/counter.ex and add the following:
defmodule LiveViewCounter.Count do
use GenServer
alias Phoenix.PubSub
@name :count_server
@start_value 0
# ------- External API (runs in client process) -------
def topic do
"count"
end
def start_link(_opts) do
GenServer.start_link(__MODULE__, @start_value, name: @name)
end
def incr() do
GenServer.call @name, :incr
end
def decr() do
GenServer.call @name, :decr
end
def current() do
GenServer.call @name, :current
end
def init(start_count) do
{:ok, start_count}
end
# ------- Implementation (Runs in GenServer process) -------
def handle_call(:current, _from, count) do
{:reply, count, count}
end
def handle_call(:incr, _from, count) do
make_change(count, +1)
end
def handle_call(:decr, _from, count) do
make_change(count, -1)
end
defp make_change(count, change) do
new_count = count + change
PubSub.broadcast(LiveViewCounter.PubSub, topic(), {:count, new_count})
{:reply, new_count, new_count}
end
endThe GenServer runs in its own process. Other parts of the application invoke
the API in their own process, these calls are forwarded to the handle_call
functions in the GenServer process where they are processed serially.
We have also moved the PubSub publication here as well.
We are also going to need to tell the Application that it now has some business
logic; we do this in the start/2 function in the
lib/live_view_counter/application.ex file.
def start(_type, _args) do
children = [
# Start the App State
+ LiveViewCounter.Count,
# Start the Telemetry supervisor
LiveViewCounterWeb.Telemetry,
# Start the PubSub system
{Phoenix.PubSub, name: LiveViewCounter.PubSub},
# Start the Endpoint (http/https)
LiveViewCounterWeb.Endpoint
# Start a worker by calling: LiveViewCounter.Worker.start_link(arg)
# {LiveViewCounter.Worker, arg}
]
# See https://hexdocs.pm/elixir/Supervisor.html
# for other strategies and supported options
opts = [strategy: :one_for_one, name: LiveViewCounter.Supervisor]
Supervisor.start_link(children, opts)
end
...Finally, we are going to have to make some changes to the LiveView itself, it now has less to do!
defmodule LiveViewCounterWeb.Counter do
use LiveViewCounterWeb, :live_view
alias LiveViewCounter.Count
alias Phoenix.PubSub
@topic Count.topic
def mount(_params, _session, socket) do
PubSub.subscribe(LiveViewCounter.PubSub, @topic)
{:ok, assign(socket, val: Count.current()) }
end
def handle_event("inc", _, socket) do
{:noreply, assign(socket, :val, Count.incr())}
end
def handle_event("dec", _, socket) do
{:noreply, assign(socket, :val, Count.decr())}
end
def handle_info({:count, count}, socket) do
{:noreply, assign(socket, val: count)}
end
def render(assigns) do
~H"""
<div>
<h1>The count is: <%= @val %></h1>
<.button phx-click="dec">-</.button>
<.button phx-click="inc">+</.button>
</div>
"""
end
endWhat is happening now is that the initial state is being retrieved from the shared Application GenServer process and the updates are being forwarded there via its API. Finally, the Gen Server Handlers publish the new state to all the active LiveViews.
Phoenix has a very cool feature called Presence to track how many people are using our system. (It does a lot more than count users, but this is a counting app so...)
First of all we need to tell the Application we are going to use Presence.
For this we need to create a lib/live_view_counter/presence.ex file like this:
defmodule LiveViewCounter.Presence do
use Phoenix.Presence,
otp_app: :live_view_counter,
pubsub_server: LiveViewCounter.PubSub
endand tell the application about it in the lib/live_view_counter/application.ex
file (add it just below the PubSub config):
def start(_type, _args) do
children = [
# Start the App State
LiveViewCounter.Count,
# Start the Telemetry supervisor
LiveViewCounterWeb.Telemetry,
# Start the PubSub system
{Phoenix.PubSub, name: LiveViewCounter.PubSub},
+ LiveViewCounter.Presence,
# Start the Endpoint (http/https)
LiveViewCounterWeb.Endpoint
# Start a worker by calling: LiveViewCounter.Worker.start_link(arg)
# {LiveViewCounter.Worker, arg}
]
# See https://hexdocs.pm/elixir/Supervisor.html
# for other strategies and supported options
opts = [strategy: :one_for_one, name: LiveViewCounter.Supervisor]
Supervisor.start_link(children, opts)
end
The application doesn't need to know any more about the user count (it might,
but not here) so the rest of the code goes into
lib/live_view_counter_web/live/counter.ex.
- We subscribe to and participate in the Presence system (we do that in
mount) - We handle Presence updates and use the current count, adding joiners and
subtracting leavers to calculate the current numbers 'present'. We do that
in a pattern matched
handle_info. - We publish the additional data to the client in
render
defmodule LiveViewCounterWeb.Counter do
use LiveViewCounterWeb, :live_view
alias LiveViewCounter.Count
alias Phoenix.PubSub
+ alias LiveViewCounter.Presence
@topic Count.topic
+ @presence_topic "presence"
def mount(_params, _session, socket) do
PubSub.subscribe(LiveViewCounter.PubSub, @topic)
+ Presence.track(self(), @presence_topic, socket.id, %{})
+ LiveViewCounterWeb.Endpoint.subscribe(@presence_topic)
+
+ initial_present =
+ Presence.list(@presence_topic)
+ |> map_size
+ {:ok, assign(socket, val: Count.current(), present: initial_present) }
- {:ok, assign(socket, val: Count.current()) }
end
def handle_event("inc", _, socket) do
{:noreply, assign(socket, :val, Count.incr())}
end
def handle_event("dec", _, socket) do
{:noreply, assign(socket, :val, Count.decr())}
end
def handle_info({:count, count}, socket) do
{:noreply, assign(socket, val: count)}
end
+ def handle_info(
+ %{event: "presence_diff", payload: %{joins: joins, leaves: leaves}},
+ %{assigns: %{present: present}} = socket
+ ) do
+ new_present = present + map_size(joins) - map_size(leaves)
+
+ {:noreply, assign(socket, :present, new_present)}
+ end
def render(assigns) do
~H"""
<div>
<h1>The count is: <%= @val %></h1>
<.button phx-click="dec">-</.button>
<.button phx-click="inc">+</.button>
+ <h1>Current users: <%= @present %></h1>
</div>
"""
end
endNow, as you open and close your incognito windows you will get a count of how many are running.
Once you have implemented the solution - before if you are using TDD - you need to make sure that the new code is properly tested.
We had a small test that showed that we were showing the counter in the web page, but let's test some of the new logic we added to the "test/live_view_counter_web/live/counter_test.exs" file
defmodule LiveViewCounterWeb.CounterTest do
use LiveViewCounterWeb.ConnCase
import Phoenix.LiveViewTest
test "connected mount", %{conn: conn} do
{:ok, _view, html} = live(conn, "/")
current = LiveViewCounter.Count.current()
assert html =~ "count is: #{current}"
end
endWe load the cases and the LiveViewTest and start testing that the connnection shows the current number of users when connecting.
Let's add logic to test increments and decrements
test "Increment", %{conn: conn} do
{:ok, view, html} = live(conn, "/")
current = LiveViewCounter.Count.current()
assert html =~ "count is: #{current}"
assert render_click(view, :inc) =~ "count is: #{current + 1}"
end
test "Decrement", %{conn: conn} do
{:ok, view, html} = live(conn, "/")
current = LiveViewCounter.Count.current()
assert html =~ "count is: #{current}"
assert render_click(view, :dec) =~ "count is: #{current - 1}"
endSome more tests for the logic when a new user is connected
test "handle_info/2 Count Update", %{conn: conn} do
{:ok, view, disconnected_html} = live(conn, "/")
current = LiveViewCounter.Count.current()
assert disconnected_html =~ "count is: #{current}"
assert render(view) =~ "count is: #{current}"
send(view.pid, {:count, 2})
assert render(view) =~ "count is: 2"
endAnd lastly the logic that follows presence
test "handle_info/2 Presence Update - Joiner", %{conn: conn} do
{:ok, view, html} = live(conn, "/")
assert html =~ "Current users: 1"
send(view.pid, %{
event: "presence_diff",
payload: %{joins: %{"phx-Fhb_dqdqsOCzKQAl" => %{metas: [%{phx_ref: "Fhb_dqdrwlCmfABl"}]}},
leaves: %{}}})
assert render(view) =~ "Current users: 2"
end
test "handle_info/2 Presence Update - Leaver", %{conn: conn} do
{:ok, view, html} = live(conn, "/")
assert html =~ "Current users: 1"
send(view.pid, %{
event: "presence_diff",
payload: %{joins: %{},
leaves: %{"phx-Fhb_dqdqsOCzKQAl" => %{metas: [%{phx_ref: "Fhb_dqdrwlCmfABl"}]}}}})
assert render(view) =~ "Current users: 0"
endCredit for inspiring this tutorial goes to Dennis Beatty @dnsbty for his superb post: https://dennisbeatty.com/2019/03/19/how-to-create-a-counter-with-phoenix-live-view.html and corresponding video: youtu.be/2bipVjOcvdI
We recommend everyone learning Elixir
subscribe to his YouTube channel and watch all his videos
as they are a superb resource!
The 3 key differences between this tutorial and Dennis' original post are:
- Complete code commit (snapshot) at the end of each section
(not just inline snippets of code).
We feel that having the complete code speeds up learning significantly, especially if (when) we get stuck. - Latest Phoenix, Elixir and LiveView versions. A few updates have been made to LiveView setup, these are reflected in our tutorial which uses the latest release.
- Broadcast updates to all connected clients. So when the counter is incremented/decremented in one client, all others see the update. This is the true power and "wow moment" of LiveView!
If you are new to LiveView (and have the bandwidth), we recommend watching James @knowthen Moore's intro to LiveView where he explains the concepts: youtu.be/U_Pe8Ru06fM
Watching the video is not required; you will be able to follow the tutorial without it.
Chris McCord (creator of Phoenix and LiveView) has
github.com/chrismccord/phoenix_live_view_example
It's a great collection of examples for people who already understand LiveView.
However we feel that it is not very beginner-friendly
(at the time of writing).
Only the default "start your Phoenix server" instructions are included,
and the
dependencies have diverged
so the app does not compile/run for some people.
We understand/love that Chris is focussed building
Phoenix and LiveView so we decided to fill in the gaps
and write this beginner-focussed tutorial.
If you haven't watched Chris' Keynote from ElixirConf EU 2019, we highly recommend watching it: youtu.be/8xJzHq8ru0M
Also read the original announcement for LiveView to understand the hype!
:
https://dockyard.com/blog/2018/12/12/phoenix-liveview-interactive-real-time-apps-no-need-to-write-javascript
Sophie DeBenedetto's ElixirConf 2019 talk "Beyond LiveView: Building Real-Time features with Phoenix LiveView, PubSub, Presence and Channels (Hooks) is worth watching: youtu.be/AbNAuOQ8wBE
Related blog post: https://elixirschool.com/blog/live-view-live-component/