Struct BevyReqwest 

pub struct BevyReqwest<'w, 's> { /* private fields */ }

Systemparam to have a shorthand for creating http calls in systems

Implementations

impl<'w, 's> BevyReqwest<'w, 's>

pub fn send(&mut self, req: Request) -> BevyReqwestBuilder<'_>

Starts sending and processing the supplied reqwest::Request then use the BevyReqwestBuilder to add handlers for responses and errors

Examples found in repository

examples/post.rs (line 24)

fn send_requests(mut client: BevyReqwest) {
    let url = "https://jsonplaceholder.typicode.com/posts";
    let body = Post {
        title: "hello".into(),
        body: "world".into(),
        user_id: 1,
    };
    let req = client.post(url).json(&body).build().unwrap();
    client
        .send(req)
        .on_response(|req: On<ReqwestResponseEvent>| {
            let req = req.event();
            let res = req.as_str();
            bevy::log::info!("return data: {res:?}");
        });
}

examples/json.rs (line 22)

fn send_requests(mut client: BevyReqwest) {
    let url = "https://bored-api.appbrewery.com/random";

    // use regular reqwest http calls, then poll them to completion.
    let reqwest_request = client.get(url).build().unwrap();

    client
        // Sends the created http request
        .send(reqwest_request)
        // The response from the http request can be reached using an observersystem
        .on_json_response(|trigger: On<JsonResponse<Bored>>| {
            let data: &Bored = &trigger.event().data;
            // let headers = req.response_headers();
            bevy::log::info!("data: {data:?}");
        })
        // In case of request error, it can be reached using an observersystem
        .on_error(|trigger: On<ReqwestErrorEvent>| {
            let e = &trigger.event().error;
            bevy::log::info!("error: {e:?}");
        });
}

examples/minimal.rs (line 21)

fn send_requests(mut client: BevyReqwest) {
    let url = "https://bored-api.appbrewery.com/random";

    // use regular reqwest http calls, then poll them to completion.
    let reqwest_request = client.get(url).build().unwrap();

    client
        // Sends the created http request
        .send(reqwest_request)
        // The response from the http request can be reached using an observersystem,
        // where the only requirement is that the first parameter in the system is the specific Trigger type
        // the rest is the same as a regular system
        .on_response(
            |trigger: On<ReqwestResponseEvent>, mut history: ResMut<History>| {
                let response = trigger.event();
                let data = response.as_str();
                let status = response.status();
                // let headers = req.response_headers();
                bevy::log::info!("code: {status}, data: {data:?}");
                if let Ok(data) = data {
                    history.responses.push(format!("OK: {data}"));
                }
            },
        )
        // In case of request error, it can be reached using an observersystem as well
        .on_error(
            |trigger: On<ReqwestErrorEvent>, mut history: ResMut<History>| {
                let e = &trigger.event().entity;
                bevy::log::info!("error: {e:?}");
                history.responses.push(format!("ERROR: {e:?}"));
            },
        );
}

pub fn send_using_entity( &mut self, entity: Entity, req: Request, ) -> Result<BevyReqwestBuilder<'_>, Box<dyn Error>>

Starts sending and processing the supplied reqwest::Request on the supplied Entity if it exists and then use the BevyReqwestBuilder to add handlers for responses and errors

pub fn client(&self) -> &Client

get access to the underlying ReqwestClient

Methods from Deref<Target = Client>

pub fn get<U>(&self, url: U) -> RequestBuilder

where U: IntoUrl,

Convenience method to make a GET request to a URL.

Errors

This method fails whenever the supplied Url cannot be parsed.

Examples found in repository

examples/json.rs (line 18)

fn send_requests(mut client: BevyReqwest) {
    let url = "https://bored-api.appbrewery.com/random";

    // use regular reqwest http calls, then poll them to completion.
    let reqwest_request = client.get(url).build().unwrap();

    client
        // Sends the created http request
        .send(reqwest_request)
        // The response from the http request can be reached using an observersystem
        .on_json_response(|trigger: On<JsonResponse<Bored>>| {
            let data: &Bored = &trigger.event().data;
            // let headers = req.response_headers();
            bevy::log::info!("data: {data:?}");
        })
        // In case of request error, it can be reached using an observersystem
        .on_error(|trigger: On<ReqwestErrorEvent>| {
            let e = &trigger.event().error;
            bevy::log::info!("error: {e:?}");
        });
}

examples/minimal.rs (line 17)

fn send_requests(mut client: BevyReqwest) {
    let url = "https://bored-api.appbrewery.com/random";

    // use regular reqwest http calls, then poll them to completion.
    let reqwest_request = client.get(url).build().unwrap();

    client
        // Sends the created http request
        .send(reqwest_request)
        // The response from the http request can be reached using an observersystem,
        // where the only requirement is that the first parameter in the system is the specific Trigger type
        // the rest is the same as a regular system
        .on_response(
            |trigger: On<ReqwestResponseEvent>, mut history: ResMut<History>| {
                let response = trigger.event();
                let data = response.as_str();
                let status = response.status();
                // let headers = req.response_headers();
                bevy::log::info!("code: {status}, data: {data:?}");
                if let Ok(data) = data {
                    history.responses.push(format!("OK: {data}"));
                }
            },
        )
        // In case of request error, it can be reached using an observersystem as well
        .on_error(
            |trigger: On<ReqwestErrorEvent>, mut history: ResMut<History>| {
                let e = &trigger.event().entity;
                bevy::log::info!("error: {e:?}");
                history.responses.push(format!("ERROR: {e:?}"));
            },
        );
}

pub fn post<U>(&self, url: U) -> RequestBuilder

where U: IntoUrl,

Convenience method to make a POST request to a URL.

Errors

This method fails whenever the supplied Url cannot be parsed.

Examples found in repository

examples/post.rs (line 22)

fn send_requests(mut client: BevyReqwest) {
    let url = "https://jsonplaceholder.typicode.com/posts";
    let body = Post {
        title: "hello".into(),
        body: "world".into(),
        user_id: 1,
    };
    let req = client.post(url).json(&body).build().unwrap();
    client
        .send(req)
        .on_response(|req: On<ReqwestResponseEvent>| {
            let req = req.event();
            let res = req.as_str();
            bevy::log::info!("return data: {res:?}");
        });
}

pub fn put<U>(&self, url: U) -> RequestBuilder

where U: IntoUrl,

Convenience method to make a PUT request to a URL.

Errors

This method fails whenever the supplied Url cannot be parsed.

pub fn patch<U>(&self, url: U) -> RequestBuilder

where U: IntoUrl,

Convenience method to make a PATCH request to a URL.

Errors

This method fails whenever the supplied Url cannot be parsed.

pub fn delete<U>(&self, url: U) -> RequestBuilder

where U: IntoUrl,

Convenience method to make a DELETE request to a URL.

Errors

This method fails whenever the supplied Url cannot be parsed.

pub fn head<U>(&self, url: U) -> RequestBuilder

where U: IntoUrl,

Convenience method to make a HEAD request to a URL.

Errors

This method fails whenever the supplied Url cannot be parsed.

pub fn request<U>(&self, method: Method, url: U) -> RequestBuilder

where U: IntoUrl,

Start building a Request with the Method and Url.

Returns a RequestBuilder, which will allow setting headers and the request body before sending.

Errors

This method fails whenever the supplied Url cannot be parsed.

pub fn execute( &self, request: Request, ) -> impl Future<Output = Result<Response, Error>>

Executes a Request.

A Request can be built manually with Request::new() or obtained from a RequestBuilder with RequestBuilder::build().

You should prefer to use the RequestBuilder and RequestBuilder::send().

Errors

This method fails if there was an error while sending request, redirect loop was detected or redirect limit was exhausted.

Trait Implementations

impl<'w, 's> Deref for BevyReqwest<'w, 's>

type Target = Client

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl SystemParam for BevyReqwest<'_, '_>

type State = FetchState

Used to store data which persists across invocations of a system.

type Item<'w, 's> = BevyReqwest<'w, 's>

The item type returned when constructing this system param. The value of this associated type should be Self, instantiated with new lifetimes.

fn init_state(world: &mut World) -> Self::State

Creates a new instance of this param’s State.

fn init_access( state: &Self::State, system_meta: &mut SystemMeta, component_access_set: &mut FilteredAccessSet, world: &mut World, )

Registers any World access used by this SystemParam

fn apply(state: &mut Self::State, system_meta: &SystemMeta, world: &mut World)

Applies any deferred mutations stored in this SystemParam’s state. This is used to apply Commands during ApplyDeferred.

fn queue( state: &mut Self::State, system_meta: &SystemMeta, world: DeferredWorld<'_>, )

Queues any deferred mutations to be applied at the next ApplyDeferred.

unsafe fn validate_param<'w, 's>( state: &'s mut Self::State, _system_meta: &SystemMeta, _world: UnsafeWorldCell<'w>, ) -> Result<(), SystemParamValidationError>

Validates that the param can be acquired by the get_param.

unsafe fn get_param<'w, 's>( state: &'s mut Self::State, system_meta: &SystemMeta, world: UnsafeWorldCell<'w>, change_tick: Tick, ) -> Self::Item<'w, 's>

Creates a parameter to be passed into a SystemParamFunction.

impl<'w, 's> ReadOnlySystemParam for BevyReqwest<'w, 's>

where Commands<'w, 's>: ReadOnlySystemParam, Res<'w, ReqwestClient>: ReadOnlySystemParam,