Implement a FIDL client

Prerequisites

This tutorial builds on the FIDL server tutorial. For the full set of FIDL tutorials, refer to the overview.

Overview

This tutorial implements a client for a FIDL protocol and runs it against the server created in the previous tutorial. The client in this tutorial is asynchronous. There is an alternate tutorial for synchronous clients.

If you want to write the code yourself, delete the following directories:

rm -r examples/fidl/hlcpp/client/*

Create the component

Create a new component project at examples/fidl/hlcpp/client:

1. Add a main() function to examples/fidl/hlcpp/client/main.cc:

   int main(int argc, const char** argv) {
     printf("Hello, world!\n");
     return 0;
   }
   

2. Declare a target for the client in examples/fidl/hlcpp/client/BUILD.gn:

   import("//build/components.gni")
   
   
   # Declare an executable for the client.
   executable("bin") {
     output_name = "fidl_echo_hlcpp_client"
     sources = [ "main.cc" ]
   }
   
   fuchsia_component("echo-client") {
     component_name = "echo_client"
     manifest = "meta/client.cml"
     deps = [ ":bin" ]
   }
   

3. Add a component manifest in examples/fidl/hlcpp/client/meta/client.cml:

   {
       include: [ "syslog/client.shard.cml" ],
   
       // Information about the program to run.
       program: {
           // Use the built-in ELF runner.
           runner: "elf",
   
           // The binary to run for this component.
           binary: "bin/fidl_echo_hlcpp_client",
       },
   
       // Capabilities used by this component.
       use: [
           { protocol: "fuchsia.examples.Echo" },
       ],
   }
   
   

4. Once you have created your component, ensure that you can add it to the build configuration:

   fx set core.x64 --with //examples/fidl/hlcpp/client:echo-client

5. Build the Fuchsia image:

   fx build

Edit GN dependencies

1. Add the following dependencies:

     deps = [
       "//examples/fidl/fuchsia.examples:fuchsia.examples_hlcpp",
       "//sdk/lib/async-loop:async-loop-cpp",
       "//sdk/lib/async-loop:async-loop-default",
       "//sdk/lib/sys/cpp",
     ]
   
   

2. Then, include them in main.cc:

   #include <fuchsia/examples/cpp/fidl.h>
   #include <lib/async-loop/cpp/loop.h>
   #include <lib/async-loop/default.h>
   #include <lib/sys/cpp/component_context.h>
   

   The reason for including these dependencies is explained in the server tutorial.

Connect to the server

The steps in this section explain how to add code to the main() function that connects the client to the server and makes requests to it.

Initialize the event loop

As in the server, the code first sets up an async loop so that the client can listen for incoming responses from the server without blocking.

int main(int argc, const char** argv) {
  async::Loop loop(&kAsyncLoopConfigAttachToCurrentThread);

  fuchsia::examples::EchoPtr echo_proxy;
  auto context = sys::ComponentContext::Create();
  context->svc()->Connect(echo_proxy.NewRequest());

  echo_proxy.set_error_handler([&loop](zx_status_t status) {
    printf("Error reading incoming message: %d\n", status);
    loop.Quit();
  });

  int num_responses = 0;
  echo_proxy->SendString("hi");
  echo_proxy->EchoString("hello", [&](std::string response) {
    printf("Got response %s\n", response.c_str());
    if (++num_responses == 2) {
      loop.Quit();
    }
  });
  echo_proxy.events().OnString = [&](std::string response) {
    printf("Got event %s\n", response.c_str());
    if (++num_responses == 2) {
      loop.Quit();
    }
  };

  printf("Async loop starting\n");
  loop.Run();
  printf("Async loop finished\n");
  return num_responses == 2 ? 0 : 1;
}

Initialize a proxy class

In the context of FIDL, proxy designates the code generated by the FIDL bindings that enables users to make remote procedure calls to the server. In HLCPP, the proxy takes the form of a class with methods corresponding to each FIDL protocol method.

The code then creates a proxy class for the Echo protocol, and connects it to the server.

int main(int argc, const char** argv) {
  async::Loop loop(&kAsyncLoopConfigAttachToCurrentThread);

  fuchsia::examples::EchoPtr echo_proxy;
  auto context = sys::ComponentContext::Create();
  context->svc()->Connect(echo_proxy.NewRequest());

  echo_proxy.set_error_handler([&loop](zx_status_t status) {
    printf("Error reading incoming message: %d\n", status);
    loop.Quit();
  });

  int num_responses = 0;
  echo_proxy->SendString("hi");
  echo_proxy->EchoString("hello", [&](std::string response) {
    printf("Got response %s\n", response.c_str());
    if (++num_responses == 2) {
      loop.Quit();
    }
  });
  echo_proxy.events().OnString = [&](std::string response) {
    printf("Got event %s\n", response.c_str());
    if (++num_responses == 2) {
      loop.Quit();
    }
  };

  printf("Async loop starting\n");
  loop.Run();
  printf("Async loop finished\n");
  return num_responses == 2 ? 0 : 1;
}

• fuchsia::examples::EchoPtr is an alias for fidl::InterfaceRequest<fuchsia::examples::Echo> generated by the bindings.
• Analogous to the fidl::Binding<fuchsia::examples::Echo> used in the server, fidl::InterfaceRequest<fuchsia::examples::Echo> is parameterized by a FIDL protocol and a channel it will proxy requests over the channel, and listen for incoming responses and events.
• The code calls EchoPtr::NewRequest(), which creates a channel, binds the class to one end of the channel, and returns the other end of the channel.
• The returned end of the channel is passed to sys::ServiceDirectory::Connect().
  • Analogous to the call to context->out()->AddPublicService() on the server side, Connect has an implicit second parameter here, which is the protocol name ("fuchsia.examples.Echo"). This is where the input to the handler defined in the previous tutorial comes from: the client passes it in to Connect, which then passes it to the handler.

An important point to note here is that this code assumes that /svc already contains an instance of the Echo protocol. This is not the case by default because of the sandboxing provided by the component framework.

Set an error handler

Finally, the code sets an error handler for the proxy:

int main(int argc, const char** argv) {
  async::Loop loop(&kAsyncLoopConfigAttachToCurrentThread);

  fuchsia::examples::EchoPtr echo_proxy;
  auto context = sys::ComponentContext::Create();
  context->svc()->Connect(echo_proxy.NewRequest());

  echo_proxy.set_error_handler([&loop](zx_status_t status) {
    printf("Error reading incoming message: %d\n", status);
    loop.Quit();
  });

  int num_responses = 0;
  echo_proxy->SendString("hi");
  echo_proxy->EchoString("hello", [&](std::string response) {
    printf("Got response %s\n", response.c_str());
    if (++num_responses == 2) {
      loop.Quit();
    }
  });
  echo_proxy.events().OnString = [&](std::string response) {
    printf("Got event %s\n", response.c_str());
    if (++num_responses == 2) {
      loop.Quit();
    }
  };

  printf("Async loop starting\n");
  loop.Run();
  printf("Async loop finished\n");
  return num_responses == 2 ? 0 : 1;
}

Send requests to the server

The code makes two requests to the server:

• An EchoString request
• A SendString request

int main(int argc, const char** argv) {
  async::Loop loop(&kAsyncLoopConfigAttachToCurrentThread);

  fuchsia::examples::EchoPtr echo_proxy;
  auto context = sys::ComponentContext::Create();
  context->svc()->Connect(echo_proxy.NewRequest());

  echo_proxy.set_error_handler([&loop](zx_status_t status) {
    printf("Error reading incoming message: %d\n", status);
    loop.Quit();
  });

  int num_responses = 0;
  echo_proxy->SendString("hi");
  echo_proxy->EchoString("hello", [&](std::string response) {
    printf("Got response %s\n", response.c_str());
    if (++num_responses == 2) {
      loop.Quit();
    }
  });
  echo_proxy.events().OnString = [&](std::string response) {
    printf("Got event %s\n", response.c_str());
    if (++num_responses == 2) {
      loop.Quit();
    }
  };

  printf("Async loop starting\n");
  loop.Run();
  printf("Async loop finished\n");
  return num_responses == 2 ? 0 : 1;
}

For EchoString the code passes in a callback to handle the response. SendString does not require such a callback because the method does not have any response.

Set an event handler

The code then sets a handler for any incoming OnString events:

int main(int argc, const char** argv) {
  async::Loop loop(&kAsyncLoopConfigAttachToCurrentThread);

  fuchsia::examples::EchoPtr echo_proxy;
  auto context = sys::ComponentContext::Create();
  context->svc()->Connect(echo_proxy.NewRequest());

  echo_proxy.set_error_handler([&loop](zx_status_t status) {
    printf("Error reading incoming message: %d\n", status);
    loop.Quit();
  });

  int num_responses = 0;
  echo_proxy->SendString("hi");
  echo_proxy->EchoString("hello", [&](std::string response) {
    printf("Got response %s\n", response.c_str());
    if (++num_responses == 2) {
      loop.Quit();
    }
  });
  echo_proxy.events().OnString = [&](std::string response) {
    printf("Got event %s\n", response.c_str());
    if (++num_responses == 2) {
      loop.Quit();
    }
  };

  printf("Async loop starting\n");
  loop.Run();
  printf("Async loop finished\n");
  return num_responses == 2 ? 0 : 1;
}

Terminate the event loop

The code waits to receive both a response to the EchoString method as well as an OnString event (which in the current implementation is sent after receiving a SendString request) before quitting from the loop. The code returns a successful exit code only if it receives both a response and an event:

int main(int argc, const char** argv) {
  async::Loop loop(&kAsyncLoopConfigAttachToCurrentThread);

  fuchsia::examples::EchoPtr echo_proxy;
  auto context = sys::ComponentContext::Create();
  context->svc()->Connect(echo_proxy.NewRequest());

  echo_proxy.set_error_handler([&loop](zx_status_t status) {
    printf("Error reading incoming message: %d\n", status);
    loop.Quit();
  });

  int num_responses = 0;
  echo_proxy->SendString("hi");
  echo_proxy->EchoString("hello", [&](std::string response) {
    printf("Got response %s\n", response.c_str());
    if (++num_responses == 2) {
      loop.Quit();
    }
  });
  echo_proxy.events().OnString = [&](std::string response) {
    printf("Got event %s\n", response.c_str());
    if (++num_responses == 2) {
      loop.Quit();
    }
  };

  printf("Async loop starting\n");
  loop.Run();
  printf("Async loop finished\n");
  return num_responses == 2 ? 0 : 1;
}

Run the client

In order for the client and server to communicate using the Echo protocol, component framework must route the fuchsia.examples.Echo capability from the server to the client. For this tutorial, a realm component is provided to declare the appropriate capabilities and routes.

1. Configure your build to include the provided package that includes the echo realm, server, and client:

   fx set core.x64 --with //examples/fidl/hlcpp:echo-hlcpp-client

2. Build the Fuchsia image:

   fx build

3. Run the echo_realm component. This creates the client and server component instances and routes the capabilities:

   ffx component run /core/ffx-laboratory:echo_realm fuchsia-pkg://fuchsia.com/echo-hlcpp-client#meta/echo_realm.cm

4. Start the echo_client instance:

   ffx component start /core/ffx-laboratory:echo_realm/echo_client

The server component starts when the client attempts to connect to the Echo protocol. You should see output similar to the following in the device logs (ffx log):

[echo_server][][I] Running echo server
[echo_client][][I] Got event hi
[echo_client][][I] Got response hello

Terminate the realm component to stop execution and clean up the component instances:

ffx component destroy /core/ffx-laboratory:echo_realm