Struct PortalHost 

pub struct PortalHost { /* private fields */ }

The shell’s half of a portal: requests out, host facts in, one gate.

Implementations

impl PortalHost

pub fn new(portal: Box<dyn Portal>) -> Self

A host over portal. A cloud push may be sent as soon as the game has something to store.

pub fn pull_first(portal: Box<dyn Portal>) -> Self

A host over portal that refuses cloud pushes until a read has resolved.

A game that loads its save and autosaves on every change wants this: a push that lands before the read would store a fresh default over the save the player came back for.

pub fn none() -> Self

The host a build without a portal gets: every request is refused with Refusal::NoPortal, nothing hangs, and the gate suspends only for what the game itself reports.

pub fn label(&self) -> &str

The backend’s name, for logs.

pub fn status(&self) -> PortalStatus

What the host can do right now.

pub fn view(&self) -> PortalView

The portal’s half of the gate.

pub fn loaded(&mut self)

The load finished. The host is told on the first playable frame, see PortalHost::ready, because a host that removes its loading overlay on game_ready must remove it over a frame the player can see.

pub fn ready(&mut self) -> Result<bool, Refusal>

The first playable frame is up: send game_ready, once.

Returns whether this call sent it. false means there was nothing to send: a second call, or one made before PortalHost::loaded. The host rejects a second game_ready, and nothing in the bridge can report that rejection, so this never sends one.

pub fn notify(&mut self, notice: HostNotice) -> Result<(), Refusal>

Tell the host something itself. The gate sends the gameplay notices on its own; this is for a game that has something else to say.

pub fn update(&mut self, dt: Duration)

Advance the portal by one frame: read the lifecycle, hand the backend’s inbox over, and release an ad that outlived its deadline.

Call once per frame, suspended or not: the ad deadline has to run while the game is held by the ad.

pub fn gate(&mut self, game: GameState) -> Suspend

Settle this frame’s gate, and tell the host when the answer changed.

pub fn take_reports(&mut self) -> Vec<PortalReport>

Everything the shell decided since the last call.

pub fn show_ad( &mut self, kind: AdKind, placement: Option<&str>, ) -> Result<(), AdRefused>

Ask the host for an ad. placement names a placement from the game’s config; None asks for the one the config declares.

A taken request holds gameplay the next time the gate is settled, see PortalHost::ad_pending, and ends in a PortalReport::AdFinished whichever way the host takes it.

A refused rewarded ad pays nothing. A game that wants to be generous where no ad can run (the games’ desktop rule: an offline rewarded break always pays out) grants the reward from that refusal itself, because the policy is the game’s and not the portal’s.

pub fn ad_pending(&self) -> bool

Whether an ad is in flight: taken, and not finished or released yet.

pub fn ad_visible(&self) -> bool

Whether the host reported an ad on screen.

pub fn ad_kind(&self) -> Option<AdKind>

The kind of the ad in flight, when there is one.

pub fn cloud_pull(&mut self) -> Result<(), Refusal>

Ask for the stored save. The answer arrives as PortalReport::CloudPulled.

pub fn cloud_push(&mut self, payload: &[u8]) -> Result<(), CloudRefused>

Store this payload under the game’s cloud key. The answer arrives as PortalReport::CloudStored.

The payload is opaque here, and the game’s save type stays out of the portal: what goes up is what comes back from PortalReport::CloudPulled, byte for byte, so a game hands over its own serialized save and parses it back itself.

pub fn cloud_ready(&self) -> bool

Whether a cloud read has resolved: the host answered, nothing stored counting as an answer, or it has no cloud at all.

A read the host refused is not an answer: it may have been transient, and the save it would have returned may be up there.

Trait Implementations

impl Default for PortalHost

fn default() -> Self

Returns the “default value” for a type.