blob: 88a7215d12b111cabc3c506b0a66544433f3ec8e [file] [log] [blame] [view]
# How-To: Write a Module in C++
> DEPRECATION WARNING: The Modular framework is being deprecated in favor of
> the [Session Framework](/docs/concepts/session/introduction.md).
## Overview
A `Module` is a UI component that can participate in a [Story](link to story doc),
potentially composed of many different `Module`s. A `Module`'s lifecycle is tightly
bound to the story to which it was added. In addition to the capabilities
provided to all Peridot components via `fuchsia::modular::ComponentContext`, a `Module` is given
additional capabilities via its `fuchsia::modular::ModuleContext`.
## `SimpleMod`
### Mod Initialization
The first step to writing a `Module` is implementing the initializer.
```c++
#include <lib/sys/cpp/component_context.h>
#include <lib/async-loop/cpp/loop.h>
#include <lib/async-loop/default.h>
#include <ui/cpp/fidl.h>
#include "src/modular/lib/app_driver/cpp/module_driver.h"
namespace simple {
class SimpleModule : fuchsia::ui::app::ViewProvider {
public:
SimpleModule(
modular::ModuleHost* module_host,
fidl::InterfaceRequest<fuchsia::ui::app::ViewProvider> view_provider_request)
: view_provider_binding_(this) {
view_provider_binding_.Bind(std::move(view_provider_request));
}
private:
modular::ModuleHost* module_host_;
fidl::Binding<fuchsia::ui::app::ViewProvider> view_provider_binding_;
std::set<std::unique_ptr<SimpleView>> views_;
};
} // namespace simple
```
The `ModuleHost` provides `SimpleModule` with its `StartupContext` and
`fuchsia::modular::ModuleContext`.
The `ViewProvider` request allows the system to connect to `SimpleModule`'s view.
TODO: Update guide to explain view connections.
### Connecting to `SimpleAgent`
See [how to write an agent](how_to_write_an_agent_cc.md) to learn how to connect
to a service provided by an Agent.
### Running the Module
```c++
int main(int argc, const char** argv) {
async::Loop loop(&kAsyncLoopConfigAttachToCurrentThread);
auto context = sys::ComponentContext::CreateAndServeOutgoingDirectory();
modular::ModuleDriver<simple::SimpleModule> driver(context.get(),
[&loop] { loop.Quit(); });
loop.Run();
return 0;
}
```
`ModuleDriver` is a helper class that manages the `Module`'s lifecyle. Here it is
given a newly created `StartupContext` and a callback that will be executed
when the `Module` exits. `ModuleDriver` requires `SimpleModule` to implement the
constructor shown above, as well as a `Terminate`:
```c++
void Terminate(fit::function<void()> done);
```
The module is responsible for calling `done` once its shutdown sequence is complete.