Struct crux_core::capability::CapabilityContext

pub struct CapabilityContext<Op, Event>
where
    Op: Operation,
{ /* private fields */ }

An interface for capabilities to interact with the app and the shell.

To use update_app, notify_shell or request_from_shell, spawn a task first.

For example (from crux_time)

pub fn get<F>(&self, callback: F)
where
    F: FnOnce(TimeResponse) -> Ev + Send + Sync + 'static,
{
    let ctx = self.context.clone();
    self.context.spawn(async move {
        let response = ctx.request_from_shell(TimeRequest).await;

        ctx.update_app(callback(response));
    });
}

Implementations

impl<Op, Ev> CapabilityContext<Op, Ev>

where Op: Operation, Ev: 'static,

pub fn request_from_shell(&self, operation: Op) -> ShellRequest<Op::Output>

Send an effect request to the shell, expecting an output. The provided operation describes the effect input in a serialisable fashion, and must implement the Operation trait to declare the expected output type.

request_from_shell returns a future of the output, which can be awaited. You should only call this method inside an async task created with CapabilityContext::spawn.

impl<Op, Ev> CapabilityContext<Op, Ev>

where Op: Operation, Ev: 'static,

pub fn stream_from_shell(&self, operation: Op) -> ShellStream<Op::Output>

Send an effect request to the shell, expecting a stream of responses

impl<Op, Ev> CapabilityContext<Op, Ev>

where Op: Operation, Ev: 'static,

pub fn spawn(&self, f: impl Future<Output = ()> + 'static + Send)

Spawn a task to do the asynchronous work. Within the task, async code can be used to interact with the Shell and the App.

pub async fn notify_shell(&self, operation: Op)

Send an effect request to the shell in a fire and forget fashion. The provided operation does not expect anything to be returned back.

pub fn update_app(&self, event: Ev)

Send an event to the app. The event will be processed on the next run of the update loop. You can call update_app several times, the events will be queued up and processed sequentially after your async task either awaits or finishes.

pub fn map_event<NewEv, F>(&self, func: F) -> CapabilityContext<Op, NewEv>

where F: Fn(NewEv) -> Ev + Sync + Send + 'static, NewEv: 'static,

Transform the CapabilityContext into one which uses the provided function to map each event dispatched with update_app to a different event type.

This is useful when composing apps from modules to wrap a submodule’s event type with a specific variant of the parent module’s event, so it can be forwarded to the submodule when received.

In a typical case you would implement From on the submodule’s Capabilities type

impl From<&Capabilities> for child::Capabilities {
   fn from(incoming: &Capabilities) -> Self {
       child::Capabilities {
           some_capability: incoming.some_capability.map_event(Event::Submodule),
           render: incoming.render.map_event(Event::Submodule),
       }
   }
}

in the parent module’s update function, you can then call .into() on the capabilities, before passing them down to the submodule.

Trait Implementations

impl<Op, Ev> Clone for CapabilityContext<Op, Ev>

where Op: Operation,

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.