class ServiceHubConnector

ServiceHubConnector is a utility class to make connecting to fidl protocol factories easier.

To use this class, it must be extended with implementations of the

methods |ConnectToServiceHub()| and |ConnectToService()|.

NOTE: ServiceHubConnector and its subclasses must be used from the |dispatcher| thread.

This includes construction, destruction, and making calls.

For example, if you have a fidl service like:

type Error = strict enum : int32 {

PERMANENT = 1;

TRANSIENT = 2;

};

protocol ProtocolFactory {

CreateProtocol(resource struct {

protocol server_end:Protocol;

}) -> () error Error;

};

protocol Protocol {

DoAction() -> () error Error;

};

Then you could implement ServiceHubConnector like this:

class ProtocolConnector final : private ServiceHubConnector

<ProtocolFactory

, Protocol, Status>

{

public:

explicit ProtocolConnector(async_dispatcher_t*dispatcher,

fidl::UnownedClientEnd

<fuchsia

_io::Directory> directory)

: ServiceHubConnector(dispatcher), directory_(directory) {}

private:

void ConnectToServiceHub(ServiceHubConnectResolver resolver) override {

auto connection = component::ConnectAt

<ProtocolFactory

>(directory_);

if (connection.is_error()) {

resolver.resolve(std::nullopt);

} else {

resolver.resolve(std::move(connection.value()));

}

}

void ConnectToService(fidl::Client

<ProtocolFactory

>

&

factory,

ServiceConnectResolver resolver) override {

auto endpoints = fidl::CreateEndpoints

<Protocol

>();

factory

->CreateProtocol(

test_protocol::ProtocolFactoryCreateProtocolRequest(std::move(endpoints->server)))

.Then([resolver = std::move(resolver), client_end = std::move(endpoints->client)](

fidl::Result

<ProtocolFactory

::CreateProtocol>

&response

) mutable {

if (response.is_ok()) {

resolver.resolve(std::move(client_end));

} else {

resolver.resolve(std::nullopt);

}

});

}

fidl::UnownedClientEnd

<fuchsia

_io::Directory> directory_;

};

Then you could use it like:

ProtocolConnector connector(...);

connector.Do([](fidl::Client

<Protocol

>

&

protocol, DoResolver resolver) {

protocol->DoAction().Then(

[resolver = std::move(resolver)](

fidl::Result

<test

_protocol::Protocol::DoAction>

&

status) mutable {

resolver.resolve(status.is_error()

&

&

(status.error_value().is_framework_error() ||

status.error_value().domain_error() == Error::kTransient));

});

});