This tutorial builds on the Compiling FIDL tutorial. For the full set of FIDL tutorials, refer to the overview.
This tutorial shows you how to implement a FIDL protocol (fuchsia.examples.Echo
) and run it on Fuchsia. This protocol has one method of each kind: a fire and forget method, a two-way method, and an event:
{% includecode gerrit_repo="fuchsia/fuchsia" gerrit_path="examples/fidl/fuchsia.examples/echo.test.fidl" region_tag="echo" %}
This document covers how to complete the following tasks:
The tutorial starts by creating a component that is served to a Fuchsia device and run. Then, it gradually adds functionality to get the server up and running.
If you want to write the code yourself, delete the following directories:
rm -r examples/fidl/hlcpp/server/*
To create a component:
Add a main()
function to examples/fidl/hlcpp/server/main.cc
:
#include <stdio.h> int main(int argc, const char** argv) { printf("Hello, world!\n"); return 0; }
Declare a target for the server in examples/fidl/hlcpp/server/BUILD.gn
:
{% includecode gerrit_repo="fuchsia/fuchsia" gerrit_path="examples/fidl/hlcpp/server/BUILD.gn" region_tag="imports" %} # Declare an executable for the server. This produces a binary with the # specified output name that can run on Fuchsia. executable("bin") { output_name = "fidl_echo_hlcpp_server" sources = [ "main.cc" ] } {% includecode gerrit_repo="fuchsia/fuchsia" gerrit_path="examples/fidl/hlcpp/server/BUILD.gn" region_tag="rest" %}
To get the server component up and running, there are three targets that are defined:
For more details on packages, components, and how to build them, refer to the Building components page.
Add a component manifest in examples/fidl/hlcpp/server/meta/server.cml
:
Note: The binary name in the manifest must match the output name of the executable
defined in the previous step.
{% includecode gerrit_repo="fuchsia/fuchsia" gerrit_path="examples/fidl/hlcpp/server/meta/server.cml" region_tag="example_snippet" %}
Add the server to your build configuration:
fx set core.x64 --with //examples/fidl/hlcpp/server:echo-hlcpp-server
Note: This build configuration assumes your device target is the emulator. To run the example on a physical device, select the appropriate product configuration for your hardware.
Build the Fuchsia image:
fx build
Add the fuchsia.examples
FIDL library target as a dependency of your executable
in examples/fidl/hlcpp/server/BUILD.gn
:
executable("bin") { output_name = "fidl_echo_hlcpp_server" sources = [ "main.cc" ] {{ '<strong>' }}deps = [ "//examples/fidl/fuchsia.examples" ]{{ '</strong>' }} }
Import the HLCPP bindings at the top of examples/fidl/hlcpp/server/main.cc
:
{% includecode gerrit_repo="fuchsia/fuchsia" gerrit_path="examples/fidl/hlcpp/server/main.cc" region_tag="fidl_includes" %}
Add the following to main.cc
, above the main()
function:
{% includecode gerrit_repo="fuchsia/fuchsia" gerrit_path="examples/fidl/hlcpp/server/main.cc" region_tag="server" %}
The implementation contains the following elements:
EchoString
replies with the request value by calling the callback on it.SendString
does not take a callback since this method does not have a response. Instead, the implementation sends an OnString
event using an Echo_EventSender
.Echo_EventSender
. This will be set later in the main()
function.You can verify that the implementation is correct by running:
fx build
To run a component that implements a FIDL protocol, make a request to the component manager to expose that FIDL protocol to other components. The component manager then routes any requests for the echo protocol to our server.
To fulfill these requests, the component manager requires the name of the protocol as well as a handler that it should call when it has any incoming requests to connect to a protocol matching the specified name.
The handler passed to it is a function that takes a channel (whose remote end is owned by the client), and binds it to a fidl::Binding
that has been initialized using the server implementation. The fidl::Binding
is a class from the FIDL runtime that takes a FIDL protocol implementation and a channel, and then listens on the channel for incoming requests. It will then decode the requests, dispatch them to the correct method on our server class, and write any response back to the client. Our main method will keep listening for incoming requests on an async loop.
This complete process is described in further detail in the Life of a protocol open.
This new code requires the following additional dependencies:
"//zircon/system/ulib/async-loop:async-loop-cpp"
and "//zircon/system/ulib/async-loop:async-loop-default"
: These libraries contain the async loop code."//sdk/lib/sys/cpp"
: The component framework C++ runtime, which contains utility code for interacting with the component's environment.Add the library targets as dependencies of your executable
in examples/fidl/hlcpp/server/BUILD.gn
:
{% includecode gerrit_repo="fuchsia/fuchsia" gerrit_path="examples/fidl/hlcpp/server/BUILD.gn" region_tag="bin" highlight="6,7,8" %}
Import these dependencies at the top of examples/fidl/hlcpp/server/main.cc
:
{% includecode gerrit_repo="fuchsia/fuchsia" gerrit_path="examples/fidl/hlcpp/server/main.cc" region_tag="includes" %}
The first aspect is the use of an async loop:
{% includecode gerrit_repo="fuchsia/fuchsia" gerrit_path="examples/fidl/hlcpp/server/main.cc" region_tag="main" highlight="2,15" %}
The code first initializes the loop and registers it as the default dispatcher for the current thread. This comes first, as the async code in the main()
function will register itself with the default dispatcher, which is a static thread local variable (which is why it does not need to be passed explicitly in the rest of the code). At the end of the main function, the code runs the async loop.
Then, the code initializes the fidl::Binding
as mentioned above:
{% includecode gerrit_repo="fuchsia/fuchsia" gerrit_path="examples/fidl/hlcpp/server/main.cc" region_tag="main" highlight="4,5,6" %}
In order to run, a binding needs two things:
The code also sets the event sender that is used to send events to the client. The event sender is obtained using the events()
method on the Binding
, and then passed to the EchoImpl
class.
Next, the code defines a handler for incoming requests from a client:
{% includecode gerrit_repo="fuchsia/fuchsia" gerrit_path="examples/fidl/hlcpp/server/main.cc" region_tag="main" highlight="7,8,9,10" %}
Echo
protocol, but rather a general request from a client to connect to an implementation of the Echo
protocol.fidl::InterfaceRequest<Echo>
. This is a type-safe wrapper around a channel that indicates two things:InterfaceRequest
indicates that this is the server end of a channel (i.e. a client is connected to the remote end of the channel)Echo
means that the client expects that a server implementing the Echo
protocol binds itself to this channel. The client analog of this (i.e. the type that is being used on the client side to represent the other end of this channel) is a fidl::InterfaceHandle<Echo>
.Echo
binding.Binding
starts handling messages on the channel according to the Echo
protocol. This is an example of protocol request pipelining, which is explored in a later tutorial.Finally, the code registers the handler with the component manager:
{% includecode gerrit_repo="fuchsia/fuchsia" gerrit_path="examples/fidl/hlcpp/server/main.cc" region_tag="main" highlight="11,12" %}
The first line initializes and serves the outgoing directory, which contains protocols that this component exposes to other components, and the second line adds the handler to the outgoing directory.
An implicit second parameter besides the handler is the name that this handler should be registered to. By default, this parameter is the name of the protocol being passed in, which is generated because of the presence [Discoverable]
attribute on the Echo
protocol. In other words, after executing this line you should be able to call ls
on the component's /out
directory and see an entry called fuchsia.examples.Echo
.
Rebuild:
fx build
Then run the server component:
ffx component run /core/ffx-laboratory:echo_server fuchsia-pkg://fuchsia.com/echo-hlcpp-server#meta/echo_server.cm
Note: Components are resolved using their component URL, which is determined with the fuchsia-pkg://
scheme.
You should see output similar to the following in the device logs (ffx log
):
[ffx-laboratory:echo_server][][I] Running echo server
The server is now running and waiting for incoming requests. The next step will be to write a client that sends Echo
protocol requests. For now, you can simply terminate the server component:
ffx component destroy /core/ffx-laboratory:echo_server
Note: Component instances are referenced by their component moniker, which is determined by their location in the component instance tree