Struct DriverContext 

#[non_exhaustive]
pub struct DriverContext {
    pub root_dispatcher: AsyncDispatcher,
    pub start_args: DriverStartArgs,
    pub incoming: Incoming,
    /* private fields */
}

The context arguments passed to the driver in its start arguments.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

root_dispatcher: AsyncDispatcher

A reference to the root fdf::Dispatcher for this driver.

start_args: DriverStartArgs

The original DriverStartArgs passed in as start arguments, minus any parts that were used to construct other elements of Self.

incoming: Incoming

The incoming namespace constructed from DriverStartArgs::incoming. Since producing this consumes the incoming namespace from Self::start_args, that will always be None.

Implementations

impl DriverContext

pub fn health_alert_reporter(&self) -> HealthAlertReporter

Returns a reporter through which the driver can proactively emit fuchsia.driver.framework/Driver.OnHealthAlert events after crate::Driver::start has consumed this context. The reporter is cheap to clone and may be used from any thread.

pub fn report_health_alert(&self, alert: HealthAlert)

Reports alert to the driver framework. Equivalent to self.health_alert_reporter().report_health_alert(alert); see HealthAlertReporter::report_health_alert.

pub fn take_node(&mut self) -> Result<Node, Status>

Binds the node proxy client end from the start args into a [NodeProxy] that can be used to add child nodes. Dropping this proxy will result in the node being removed and the driver starting shutdown, so it should be bound and stored in your driver object in its crate::Driver::start method.

After calling this, DriverStartArgs::node in Self::start_args will be None.

Returns [Status::INVALID_ARGS] if the node client end is not present in the start arguments.

pub fn take_config<C: Config>(&mut self) -> Result<C, Status>

Returns the component config.

After calling this, DriverStartArgs::config in Self::start_args will be None.

Returns [Status::INVALID_ARGS] if the config is not present in the start arguments.

pub fn serve_outgoing<O: ServiceObjTrait>( &mut self, outgoing_fs: &mut ServiceFs<O>, ) -> Result<(), Status>

Serves the given [ServiceFs] on the node’s outgoing directory. This can only be called once, and after this the DriverStartArgs::outgoing_dir member will be None.

Logs an error and returns [Status::INVALID_ARGS] if the outgoing directory server end is not present in the start arguments, or [Status::INTERNAL] if serving the connection failed.

pub fn publish_inspect( &self, inspector: &Inspector, scope: ScopeHandle, ) -> Result<(), Status>

Spawns a server handling fuchsia.inspect.Tree requests and a handle to the fuchsia.inspect.Tree is published using fuchsia.inspect.InspectSink.

Whenever the client wishes to stop publishing Inspect, the Controller may be dropped.

pub fn inspect_content_publisher(&self) -> Result<ContentPublisher, Status>

Returns an inspect content publisher that acts as a stream for requests for inspect data.

pub fn node_name(&self) -> Option<&str>

Returns the name of the node that the driver is bound to, if present in the start arguments.

pub fn take_node_token(&mut self) -> Option<Event>

Takes the node token from the start arguments, if the driver host provided one. The token identifies the driver’s node to other framework services, such as the power framework.

After calling this, DriverStartArgs::node_token in Self::start_args will be None.

pub fn take_power_element_token(&mut self) -> Option<Event>

Takes the power element dependency token from the start arguments. The driver host provides it when the driver’s manifest opts in to a framework-managed power element.

After calling this, the token of DriverStartArgs::power_element_args in Self::start_args will be None.

pub fn node_properties(&self) -> impl Iterator<Item = ParentProperty<'_>> + '_

Returns the properties of the driver’s parent node(s) from the start arguments, in the order the driver host provided them. See ParentProperty::parent for how the properties are grouped.

pub fn vmar(&self) -> Unowned<'_, Vmar>

Returns the VMAR which the driver can use to map memory.

If the driver was not provided with an explicit VMAR in its start arguments, the root VMAR is returned.