# Fleet Management

Connect Oden Streamer and OdenVR through Bifrost fleet management.

Last validated: 2026-05-04

Bifrost is Voysys' cloud fleet management system for Oden. It tracks which vehicles are online, lets an operator select a vehicle by name, starts and stops fleet sessions, and provides relay infrastructure for the initial secure network path. After a session is active, Oden tries to use a direct peer-to-peer path when the network allows it.

Bifrost does not replace the Streamer or Player. Oden Fleet Streamer runs on the vehicle, OdenVR or Oden Dome Player runs on the operator station, and the **Fleet Client** plugin on both sides coordinates the session through Bifrost.

In this page, **Player** means OdenVR or Oden Dome Player.

## Prerequisites

Before you connect through Bifrost, make sure the system has:

-   Oden Fleet Streamer installed on the vehicle computer. It includes the Fleet Client and Oden Control Pipeline plugins used by the fleet flow.
    
-   OdenVR or Oden Dome Player installed on the operator computer.
    
-   Activated licenses on both sides. For a headless Fleet Streamer service, activate with the command used by the service and restart it afterward.
    
-   Network access from both computers to Bifrost. The Fleet Client authenticates with Bifrost and keeps the server connection alive with heartbeats.
    
-   A Streamer project with a working video source. For a first check, use a test source before switching to real cameras.
    
-   The **Fleet Client** plugin enabled on the Player. Enable **Oden Control Pipeline** when the operator will control the vehicle. Enable **Webview** when the operator interface is a web UI.
    

If Oden Fleet Streamer was installed as a systemd service, manage it with:

```shell
sudo systemctl start oden-streamer.service
sudo systemctl status oden-streamer.service
sudo systemctl restart oden-streamer.service
```

The service uses `/opt/oden-streamer/oden-vehicle-config.vproj` as its startup project.

## Connect a Fleet Streamer and Player

1.  Start Oden Fleet Streamer on the vehicle.
    
    When the Fleet Client authenticates as a vehicle, Bifrost can list the vehicle as online. On newer Bifrost protocol versions, the Streamer requests its assigned Streamer project from the server after authentication. If no server project is available, the Streamer falls back to its local/default project.
    
2.  Start the Player on the operator station.
    
    Open the plugin list and enable **Fleet Client**. If this is a control setup, also enable **Oden Control Pipeline**. For a web-based operator interface, enable **Webview**.
    
3.  Open the Player connection UI.
    
    The Fleet Client authenticates as an operator and requests the current vehicle list from Bifrost. Each vehicle is shown by name with an availability status.
    
4.  Select the vehicle and connect.
    
    For a control session, the Player sends a control request for the vehicle name. Bifrost creates the session, selects relay information, and the two Fleet Clients exchange the link keys needed to configure the Player and Streamer network links.
    
    When the session is accepted, the Player either loads the project assigned to the vehicle or creates a Remote Streamer entity for the session. The Streamer configures its matching links, starts streaming, and enables audio sending for the session.
    
5.  Verify video and link health.
    
    Open the Remote Streamer entity on the Player to check traffic, packet loss, round-trip time, and video state. If the link starts through a relay, Oden may switch to peer-to-peer automatically when a direct path becomes available.
    
6.  Disconnect when finished.
    
    Use the disconnect button in the Player connection UI. The Fleet Client sends a disconnect request for the active session and removes the fleet-created links.
    

For a general first-stream workflow, see [Oden Quickstart](../start/quickstart.md). For a comparison with direct network links, see [Connect Player and Streamer](../start/connect-player-and-streamer.md).

## Webview Fleet Messages

A webview can manage the same fleet flow by sending named user messages through the Oden Webview SDK. Create a single `OdenLayoutClient` instance, register callbacks for incoming messages, and use the vehicle `name` when connecting. Do not use the vehicle `id` as the connect target.

```javascript
const odenClient = getOrCreateOdenLayoutClient();

const onFleetVehicles = (vehicles) => {
  // vehicles is an array:
  // [
  //   { id: string, name: string, availability: "Available" | "Monitored" | "Controlled" }
  // ]
  console.log("Online vehicles", vehicles);
};

odenClient.registerUserMessageCallback("fleet_online_vehicles", onFleetVehicles);
odenClient.sendNamedUserMessage("fleet_list_vehicles", {});
```

```javascript
odenClient.sendNamedUserMessage("fleet_connect", {
  vehicle_name: "vehicle_name"
});

odenClient.sendNamedUserMessage("fleet_disconnect", {
  vehicle_name: "vehicle_name"
});
```

`fleet_list_vehicles`

Requests the online vehicle list from Bifrost. The reply is sent back as `fleet_online_vehicles`.

`fleet_online_vehicles`

Contains an array of vehicles with `id`, `name`, and `availability`. The list is sent after a webview requests it with `fleet_list_vehicles`.

`fleet_connect`

Requests a control connection to the vehicle named by `vehicle_name`. The Fleet Client retries wanted control connections while the vehicle is missing from the local connection list.

`fleet_disconnect`

Disconnects the control session for the vehicle named by `vehicle_name`.

For the full SDK context, see [Webview and JavaScript SDK](../integrate/webview-sdk.md). For video layout from a webview, see [Player Layout](../configure/player-layout.md).

## Common Statuses

| Status | Meaning |
| --- | --- |
| Available | The vehicle is online in Bifrost and has no active control or monitor session. |
| Monitored | At least one monitor session exists for the vehicle. Control may still be available unless another operator has a control session. |
| Controlled | A control session exists for the vehicle. The Player connection UI disables starting another control session to a controlled vehicle. |
| Authentication not yet attempted | The Fleet Client has been created but has not completed its first authentication attempt. |
| Connected to `<address>` | The Fleet Client is authenticated with a Bifrost fleet server. |
| Invalid credentials | Bifrost rejected the Fleet Client credentials. Check the license or external identity token used by the application. |
| Validation error: `<message>` | Bifrost rejected the authentication request with a validation error. Use the message and application log to identify the provisioning or token problem. |

## Troubleshooting

### Vehicle Does Not Appear Online

-   Check that Oden Fleet Streamer is running on the vehicle. On Linux service installations, run `sudo systemctl status oden-streamer.service`.
    
-   Check that the Streamer is activated and that the Fleet Client plugin can authenticate. The Fleet Client GUI shows `Authentication State`.
    
-   Confirm that the vehicle computer can reach Bifrost. If it cannot, the vehicle cannot register as online.
    
-   Restart the Fleet Streamer service after activating or changing the license.
    
-   Make sure only one Oden Streamer instance is running on the vehicle unless the setup explicitly uses `--multiple-streamers`.
    

### Player Cannot See or Connect to a Vehicle

-   Enable the **Fleet Client** plugin in the Player.
    
-   Check the Player license or external identity token. `Invalid credentials` means Bifrost rejected authentication.
    
-   Verify that the vehicle name in a webview `fleet_connect` message matches the `name` field from `fleet_online_vehicles`.
    
-   If the vehicle is `Controlled`, another control session already exists. Disconnect that session before starting a new control session.
    
-   If the connection UI is hidden by project configuration, use the webview messages or the Fleet Client plugin GUI to inspect state.
    

### Connection Succeeds but Video Does Not Update

-   Verify the Streamer video input locally. Use a test source to separate camera problems from fleet/network problems.
    
-   Open the Remote Streamer entity on the Player and check packet loss, round-trip time, and whether packets are arriving.
    
-   Confirm that the Streamer project loaded after authentication. If no server-side Streamer project is available, the Streamer should load its local/default project.
    
-   Check that firewall and routing rules do not block the direct peer-to-peer path. The session can still start through a relay, but network policy can affect quality and whether P2P transition succeeds.
    

### Webview Requests Do Nothing

-   Enable the **Webview** plugin and load the page inside the Oden webview. The Oden Webview SDK message pipeline is available to pages running in Oden.
    
-   Register `fleet_online_vehicles` before sending `fleet_list_vehicles` so the response is not missed.
    
-   Send JSON payloads with the exact message names: `fleet_list_vehicles`, `fleet_connect`, and `fleet_disconnect`.
    
-   Use `vehicle_name`, not `id`, in connect and disconnect payloads.
    

## Related Pages

-   [Install Oden](../start/install-oden.md)
    
-   [Activate licenses](../start/activate-licenses.md)
    
-   [Connect Player and Streamer](../start/connect-player-and-streamer.md)
    
-   [Fleet management from a webview](../integrate/webview-sdk.md)
    
-   [Network and Remote Streamer links](../configure/network.md)