Rust SDK

extensions/<name>/
  manifest.yaml            # agent.runtime: rust, agent.entrypoint: bin/<name>
  agent/
    Cargo.toml             # the crate
    src/main.rs            # impl Plugin + run_plugin
  locales/ ...             # optional assets, same as any extension

# extensions/<name>/agent/Cargo.toml
[dependencies]
ados-sdk = { workspace = true }
tokio = { workspace = true }
rmpv = { workspace = true }
# The Plugin trait uses async methods, so implementing it needs the same
# attribute the trait was declared with.
async-trait = { workspace = true }

# Cargo.toml (workspace root)
[workspace.dependencies]
ados-sdk = { path = "../ADOSDroneAgent/crates/ados-sdk" }
ados-protocol = { path = "../ADOSDroneAgent/crates/ados-protocol" }

use std::collections::BTreeMap;

use ados_sdk::{run_plugin, Plugin, RunnerError};
use ados_sdk::context::PluginContext;
use ados_sdk::ClientError;
use async_trait::async_trait;

/// A plugin holds whatever state its hooks share.
struct MyPlugin;

#[async_trait]
impl Plugin for MyPlugin {
    fn new() -> Self {
        MyPlugin
    }

    /// Open subscriptions, register drivers, start a loop. Each call on
    /// `ctx` is gated on a manifest permission.
    async fn on_start(&mut self, ctx: &PluginContext) -> Result<(), ClientError> {
        ctx.events
            .subscribe("vehicle.*", std::sync::Arc::new(|_args| { /* ... */ }))
            .await?;
        Ok(())
    }

    /// Release anything on_start acquired.
    async fn on_stop(&mut self, _ctx: &PluginContext) -> Result<(), ClientError> {
        Ok(())
    }
}

/// Resolve when the process is asked to stop. The host stops the unit
/// with SIGTERM; SIGINT covers a foreground run.
async fn shutdown_signal() {
    use tokio::signal::unix::{signal, SignalKind};
    let mut term = signal(SignalKind::terminate()).expect("SIGTERM handler");
    let mut int = signal(SignalKind::interrupt()).expect("SIGINT handler");
    tokio::select! {
        _ = term.recv() => {}
        _ = int.recv() => {}
    }
}

#[tokio::main]
async fn main() {
    let static_config: BTreeMap<String, rmpv::Value> = BTreeMap::new();
    match run_plugin::<MyPlugin, _>(
        env!("CARGO_PKG_VERSION"),
        static_config,
        shutdown_signal(),
    )
    .await
    {
        Ok(()) => {}
        // Running the binary by hand (no host) lands here: no socket or
        // token to connect to. Report and exit non-zero rather than panic.
        Err(RunnerError::NoBridge) => {
            eprintln!("no plugin host socket/token supplied");
            std::process::exit(1);
        }
        Err(err) => {
            eprintln!("{err}");
            std::process::exit(1);
        }
    }
}

on_install -> on_enable -> on_configure(ctx, config) -> on_start
   -> (wait for shutdown) -> on_stop -> on_disable

use std::sync::Arc;
use ados_sdk::vision::Frame;

// In on_start:
let vision = ctx.vision.clone(); // a cheap clone shares the one IPC client
ctx.vision
    .subscribe_frames(None, Arc::new(move |frame: Frame| {
        // frame.descriptor + frame.pixels (resolved from the ring)
        let vision = vision.clone();
        tokio::spawn(async move {
            // publish a detection, run inference, inject pose ...
        });
    }))
    .await?;

use ados_sdk::testing::FakeVisionEngine;
use ados_protocol::framebus::FrameFormat;

let mut engine = FakeVisionEngine::new("uvc-0", 64, 48, FrameFormat::Rgb24);
engine.on_frame(|frame| {
    assert_eq!(frame.descriptor.camera_id, "uvc-0");
});
engine.push_solid(0x80);   // one grey frame
engine.deliver_all();

agent:
  runtime: rust
  entrypoint: "bin/<name>"
  isolation: subprocess
  permissions:
    - vision.frame.read
    - vision.detection.publish
  resources:
    max_ram_mb: 32
    max_cpu_percent: 10
    max_pids: 4