The callback action carries no invented permission or error. Completion reducers decode the actual typed result from ctx.input; binding an action with Unknown or a default error would preserve that placeholder instead of replacing it with the host response.
A permission request is not itself a grant. The current Android provider asks for OS permission and immediately returns its current snapshot, potentially before the user answers. That is why the interface keeps Request location access and Refresh access status separate. An explicit check does not reopen the prompt.
{"id":"fission-tabs-1","tabs":[{"index":0,"label":"src/state.rs","value":"src-state-rs"},{"index":1,"label":"src/app.rs","value":"src-app-rs"},{"index":2,"label":"src/translations.rs","value":"src-translations-rs"},{"index":3,"label":"i18n/en-US.yaml","value":"i18n-en-us-yaml"},{"index":4,"label":"i18n/es-ES.yaml","value":"i18n-es-es-yaml"},{"index":5,"label":"src/lib.rs","value":"src-lib-rs"},{"index":6,"label":"preview/lib.rs","value":"preview-lib-rs"}]}
{"id":"fission-tabs-1","index":0,"label":"src/state.rs","value":"src-state-rs"}
use fission::prelude::*;
#[derive(Debug)]
pub struct TrailReportState {
pub locale: Locale,
pub trail_segment: String,
pub observation: String,
pub permission: GeolocationPermission,
pub permission_pending: bool,
pub location_pending: bool,
pub position: Option<GeolocationPosition>,
pub issue: Option<TrailIssue>,
}
impl Default for TrailReportState {
fn default() -> Self {
Self {
locale: Locale::from("en-US"), trail_segment: String::new(),
observation: String::new(), permission: GeolocationPermission::Unknown,
permission_pending: false, location_pending: false, position: None, issue: None,
}
}
}
impl GlobalState for TrailReportState {}
impl TrailReportState {
pub fn apply_permission(&mut self, permission: GeolocationPermission) {
self.permission = permission;
if permission != GeolocationPermission::Granted { self.position = None; }
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum TrailIssue {
PermissionRequestFailed,
PermissionRefreshFailed,
PermissionRequired,
PositionDenied,
PositionUnsupported,
PositionTimedOut,
PositionUnavailable,
PositionFailed,
}
impl TrailIssue {
pub fn translation_key(self) -> &'static str {
match self {
Self::PermissionRequestFailed => "trail.error.permission_request",
Self::PermissionRefreshFailed => "trail.error.permission_refresh",
Self::PermissionRequired => "trail.error.permission_required",
Self::PositionDenied => "trail.error.position_denied",
Self::PositionUnsupported => "trail.error.position_unsupported",
Self::PositionTimedOut => "trail.error.position_timeout",
Self::PositionUnavailable => "trail.error.position_unavailable",
Self::PositionFailed => "trail.error.position_failed",
}
}
}
#[fission_reducer(SetTrailLocale)]
pub fn on_set_trail_locale(state: &mut TrailReportState, locale: Locale) {
state.locale = locale;
}
#[fission_reducer(TrailPermissionReceived)]
pub fn on_trail_permission_received(
state: &mut TrailReportState, ctx: &mut ReducerContext<TrailReportState>,
) {
state.permission_pending = false;
match ctx.input.capability_ok(REQUEST_GEOLOCATION_PERMISSION)
.or_else(|| ctx.input.capability_ok(GET_GEOLOCATION_PERMISSION)) {
Some(permission) => {
state.apply_permission(permission);
state.issue = None;
}
None => {
state.permission = GeolocationPermission::Unknown;
state.issue = Some(TrailIssue::PermissionRefreshFailed);
}
}
}
#[fission_reducer(TrailPermissionRequestFailed)]
pub fn on_trail_permission_request_failed(state: &mut TrailReportState) {
state.permission_pending = false;
state.issue = Some(TrailIssue::PermissionRequestFailed);
}
#[fission_reducer(TrailPermissionRefreshFailed)]
pub fn on_trail_permission_refresh_failed(state: &mut TrailReportState) {
state.permission_pending = false;
state.issue = Some(TrailIssue::PermissionRefreshFailed);
}
#[fission_reducer(RequestTrailPermission)]
pub fn on_request_trail_permission(
state: &mut TrailReportState,
ctx: &mut ReducerContext<TrailReportState>,
) {
if state.permission_pending || state.location_pending {
return;
}
state.permission_pending = true;
state.issue = None;
let on_ok = ctx.effects.bind(
TrailPermissionReceived,
reduce_with!(on_trail_permission_received),
);
let on_err = ctx.effects.bind(
TrailPermissionRequestFailed,
reduce_with!(on_trail_permission_request_failed),
);
ctx.effects
.geolocation()
.request_permission(GeolocationPermissionRequest {
precise: true,
background: false,
})
.on_ok(on_ok)
.on_err(on_err);
}
#[fission_reducer(RefreshTrailPermission)]
pub fn on_refresh_trail_permission(
state: &mut TrailReportState,
ctx: &mut ReducerContext<TrailReportState>,
) {
if state.permission_pending || state.location_pending {
return;
}
state.permission_pending = true;
state.issue = None;
let on_ok = ctx.effects.bind(
TrailPermissionReceived,
reduce_with!(on_trail_permission_received),
);
let on_err = ctx.effects.bind(
TrailPermissionRefreshFailed,
reduce_with!(on_trail_permission_refresh_failed),
);
ctx.effects
.geolocation()
.permission()
.on_ok(on_ok)
.on_err(on_err);
}
#[fission_reducer(TrailPositionReceived)]
pub fn on_trail_position_received(
state: &mut TrailReportState,
ctx: &mut ReducerContext<TrailReportState>,
) {
state.location_pending = false;
if let Some(position) = ctx.input.capability_ok(GET_CURRENT_POSITION) {
state.position = Some(position);
state.issue = None;
} else {
state.issue = Some(TrailIssue::PositionUnavailable);
}
}
#[fission_reducer(TrailPositionFailed)]
pub fn on_trail_position_failed(
state: &mut TrailReportState,
ctx: &mut ReducerContext<TrailReportState>,
) {
state.location_pending = false;
let error = ctx.input.capability_error(GET_CURRENT_POSITION);
let Some(error) = error else {
state.issue = Some(TrailIssue::PositionFailed);
return;
};
if error.code == "permission_denied" {
state.apply_permission(GeolocationPermission::Denied);
}
state.issue = Some(match error.code.as_str() {
"permission_denied" => TrailIssue::PositionDenied,
"unsupported" => TrailIssue::PositionUnsupported,
"timeout" => TrailIssue::PositionTimedOut,
"position_unavailable" => TrailIssue::PositionUnavailable,
_ => TrailIssue::PositionFailed,
});
}
#[fission_reducer(AddTrailMapPin)]
pub fn on_add_trail_map_pin(
state: &mut TrailReportState,
ctx: &mut ReducerContext<TrailReportState>,
) {
if state.location_pending || state.permission_pending {
return;
}
if state.permission != GeolocationPermission::Granted {
state.issue = Some(TrailIssue::PermissionRequired);
return;
}
state.location_pending = true;
state.issue = None;
let on_ok = ctx.effects.bind(
TrailPositionReceived,
reduce_with!(on_trail_position_received),
);
let on_err = ctx.effects.bind(
TrailPositionFailed,
reduce_with!(on_trail_position_failed),
);
ctx.effects
.geolocation()
.current_position(GeolocationPositionRequest {
high_accuracy: true,
timeout_ms: Some(10_000),
maximum_age_ms: Some(30_000),
})
.on_ok(on_ok)
.on_err(on_err);
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn optional_location_does_not_initialise_or_destroy_report_text() {
let mut report = TrailReportState::default();
report.trail_segment = "Ridge trail".into();
report.observation = "Fallen branch across the path".into();
report.apply_permission(GeolocationPermission::Denied);
assert!(report.position.is_none());
assert!(!report.trail_segment.is_empty());
assert!(!report.observation.is_empty());
}
}
{"id":"fission-tabs-1","index":1,"label":"src/app.rs","value":"src-app-rs"}
use fission::prelude::*;
use crate::state::*;
fission_component! {
pub TrailReportScreen<TrailReportState> {}
view(_screen, state, cx) {
let tokens = &cx.view.env().theme.tokens;
let english = with_reducer!(cx.build, SetTrailLocale(Locale::from("en-US")), on_set_trail_locale);
let spanish = with_reducer!(cx.build, SetTrailLocale(Locale::from("es-ES")), on_set_trail_locale);
let request_permission = with_reducer!(cx.build, RequestTrailPermission, on_request_trail_permission);
let refresh_permission = with_reducer!(cx.build, RefreshTrailPermission, on_refresh_trail_permission);
let add_map_pin = with_reducer!(cx.build, AddTrailMapPin, on_add_trail_map_pin);
let permission_text = match state.permission {
GeolocationPermission::Granted => cx.tr("trail.location.granted"),
GeolocationPermission::Denied => cx.tr("trail.location.denied"),
GeolocationPermission::Prompt => cx.tr("trail.location.prompt"),
GeolocationPermission::Unsupported => cx.tr("trail.location.unsupported"),
GeolocationPermission::Unknown => cx.tr("trail.location.unknown"),
};
} =>
SafeArea(
id: None,
child: Scroll(
flex_grow: 1.0,
child: Row(align_items: ir_op::AlignItems::Start, children: [
Spacer(flex_grow: 1.0),
Container(
Column(gap: tokens.spacing.m, children: [
Row(gap: tokens.spacing.s, align_items: ir_op::AlignItems::Center, children: [
Column(gap: tokens.spacing.xs, children: [
Text(cx.tr("trail.brand")).weight(tokens.typography.font_weight_bold),
Text(cx.tr("trail.section")).color(tokens.colors.text_secondary),
]),
Spacer(flex_grow: 1.0),
Button(child: Text(cx.tr("trail.locale.en")), key: "locale-en", variant: if state.locale == Locale::from("en-US") { ButtonVariant::Primary } else { ButtonVariant::Outline }, on_press: english),
Button(child: Text(cx.tr("trail.locale.es")), key: "locale-es", variant: if state.locale == Locale::from("es-ES") { ButtonVariant::Primary } else { ButtonVariant::Outline }, on_press: spanish),
]),
Column(gap: tokens.spacing.xs, children: [
Text(cx.tr("trail.title")).size(tokens.typography.heading1_size).weight(tokens.typography.font_weight_bold),
Text(cx.tr("trail.intro")).color(tokens.colors.text_secondary),
]),
Container(
Column(gap: tokens.spacing.m, children: [
Text(cx.tr("trail.report.title")).weight(tokens.typography.font_weight_bold),
TextInput(label: Some(cx.tr("trail.segment.label").into()), placeholder: Some(cx.tr("trail.segment.placeholder").into()), helper_text: Some(cx.tr("trail.segment.help").into()), bind: state.trail_segment, required: true, semantics_identifier: "trail-report.segment".to_string()),
TextInput(label: Some(cx.tr("trail.observation.label").into()), placeholder: Some(cx.tr("trail.observation.placeholder").into()), helper_text: Some(cx.tr("trail.observation.help").into()), bind: state.observation, multiline: true, required: true, semantics_identifier: "trail-report.observation".to_string()),
Text(cx.tr("trail.report.session_only")).color(tokens.colors.text_secondary),
])
)
.padding_all(tokens.spacing.m)
.bg(tokens.colors.surface)
.border(tokens.colors.border, 1.0)
.border_radius(tokens.radii.large),
SemanticsRegion(
identifier: Some("trail-report.location".to_string()),
label: Some(cx.tr("trail.location.semantics")),
child: Container(
Column(gap: tokens.spacing.m, children: [
Column(gap: tokens.spacing.xs, children: [
Text(cx.tr("trail.location.title")).weight(tokens.typography.font_weight_bold),
Text(cx.tr("trail.location.description")).color(tokens.colors.text_secondary),
]),
Text(if state.permission_pending { cx.tr("trail.location.checking") } else { permission_text })
.color(tokens.colors.text_secondary),
Row(gap: tokens.spacing.s, wrap: ir_op::FlexWrap::Wrap, children: [
Button(child: Text(cx.tr("trail.action.request")), key: "request-location", variant: ButtonVariant::Outline, disabled: state.permission_pending || state.location_pending, on_press: request_permission).semantics_identifier("trail-report.request-location".to_string()),
Button(child: Text(cx.tr("trail.action.refresh")), key: "refresh-location", variant: ButtonVariant::Outline, disabled: state.permission_pending || state.location_pending, on_press: refresh_permission).semantics_identifier("trail-report.refresh-location".to_string()),
Button(child: Text(if state.location_pending { cx.tr("trail.action.locating") } else { cx.tr("trail.action.add_pin") }), key: "add-map-pin", variant: ButtonVariant::Primary, disabled: state.location_pending || state.permission_pending || state.permission != GeolocationPermission::Granted, on_press: add_map_pin).semantics_identifier("trail-report.add-map-pin".to_string()),
]),
if state.permission_pending || state.location_pending {
Spinner(motion: Some(SpinnerMotion::Default), label: cx.tr("trail.location.checking"))
},
if let Some(position) = &state.position {
Text(cx.tr("trail.location.pin").replace("{latitude}", &format!("{:.5}", position.latitude)).replace("{longitude}", &format!("{:.5}", position.longitude)).replace("{accuracy}", &format!("{:.0}", position.accuracy_meters)))
.color(tokens.colors.primary),
} else {
Text(cx.tr("trail.location.no_pin")).color(tokens.colors.text_secondary)
},
if let Some(issue) = state.issue {
Text(cx.tr(issue.translation_key())).color(tokens.colors.error)
},
])
)
.padding_all(tokens.spacing.m)
.bg(tokens.colors.surface)
.border(tokens.colors.border, 1.0)
.border_radius(tokens.radii.large),
),
])
)
.width_length(Length::clamp(Length::points(0.0), Length::percent(100.0), Length::points(720.0)))
.padding_all(tokens.spacing.m)
.bg(tokens.colors.background),
Spacer(flex_grow: 1.0),
]),
),
)
}
{"id":"fission-tabs-1","index":2,"label":"src/translations.rs","value":"src-translations-rs"}
use std::collections::HashMap;
use fission::prelude::*;
pub fn create_env() -> Env {
let mut env = Env::default();
env.locale = Locale::from("en-US");
for (locale, source) in [
("en-US", include_str!("../i18n/en-US.yaml")),
("es-ES", include_str!("../i18n/es-ES.yaml")),
] {
let messages: HashMap<String, String> =
serde_yaml::from_str(source).expect("valid checked-in translations");
env.i18n.add_bundle(TranslationBundle { locale: Locale::from(locale), messages });
}
env
}
{"id":"fission-tabs-1","index":3,"label":"i18n/en-US.yaml","value":"i18n-en-us-yaml"}
trail.brand: "Juniper County"
trail.section: "Trail reports"
trail.locale.en: "English"
trail.locale.es: "Español"
trail.title: "Report a trail hazard"
trail.intro: "Add a segment and a clear description. A map pin is optional."
trail.report.title: "Inspection details"
trail.report.session_only: "This report stays in memory for this session. It has not been saved or sent."
trail.segment.label: "Trail segment"
trail.segment.placeholder: "For example, North Ridge · Timber bridge"
trail.segment.help: "Use the assigned segment if location is unavailable."
trail.observation.label: "What needs attention?"
trail.observation.placeholder: "Describe the hazard for the next crew."
trail.observation.help: "Include a landmark or safe approach if it helps the next crew."
trail.location.title: "Optional map pin"
trail.location.description: "Location is requested only after you choose to add a pin. The report can continue without it."
trail.location.semantics: "Optional report location"
trail.location.checking: "Checking permission…"
trail.location.granted: "Location access is granted while using this app."
trail.location.denied: "Location access is denied. Keep the segment and report text; change access in Android Settings only if a pin is needed."
trail.location.prompt: "The host has not recorded a permission choice yet. Request access when you want a pin."
trail.location.unsupported: "This host does not provide location. The report fields remain available."
trail.location.unknown: "Permission has not been checked."
trail.location.pin: "Map pin: {latitude}, {longitude} · accuracy about {accuracy} m"
trail.location.no_pin: "No coordinates are attached to this report."
trail.action.request: "Request location access"
trail.action.refresh: "Refresh access status"
trail.action.locating: "Getting location…"
trail.action.add_pin: "Add map pin"
trail.error.permission_request: "The location-access request could not be completed. The report is unchanged."
trail.error.permission_refresh: "Permission status could not be refreshed. The report is unchanged."
trail.error.permission_required: "Request and confirm location access before adding a pin."
trail.error.position_denied: "Location was denied. Continue with the assigned segment or enable access in Settings."
trail.error.position_unsupported: "This host cannot return a location. Continue with the assigned segment."
trail.error.position_timeout: "Location took too long. Try again or continue without a pin."
trail.error.position_unavailable: "No position was returned. Check location services or continue without a pin."
trail.error.position_failed: "The host could not return a position. The report text is unchanged."
{"id":"fission-tabs-1","index":4,"label":"i18n/es-ES.yaml","value":"i18n-es-es-yaml"}
trail.brand: "Condado de Juniper"
trail.section: "Informes de senderos"
trail.locale.en: "Inglés"
trail.locale.es: "Español"
trail.title: "Informar de un peligro en el sendero"
trail.intro: "Añade un tramo y una descripción clara. El punto del mapa es opcional."
trail.report.title: "Detalles de la inspección"
trail.report.session_only: "Este informe permanece en la memoria durante esta sesión. No se ha guardado ni enviado."
trail.segment.label: "Tramo del sendero"
trail.segment.placeholder: "Por ejemplo, cresta norte · puente de madera"
trail.segment.help: "Usa el tramo asignado si la ubicación no está disponible."
trail.observation.label: "¿Qué necesita atención?"
trail.observation.placeholder: "Describe el peligro para el próximo equipo."
trail.observation.help: "Añade un punto de referencia o una ruta segura si ayuda al próximo equipo."
trail.location.title: "Punto opcional en el mapa"
trail.location.description: "La ubicación solo se solicita cuando eliges añadir un punto. Puedes continuar el informe sin ella."
trail.location.semantics: "Ubicación opcional del informe"
trail.location.checking: "Comprobando el permiso…"
trail.location.granted: "El permiso de ubicación está concedido mientras se usa esta aplicación."
trail.location.denied: "Se denegó el acceso a la ubicación. Conserva el tramo y el informe; cambia el permiso en Ajustes de Android solo si necesitas un punto."
trail.location.prompt: "El sistema aún no ha registrado una decisión. Solicita acceso cuando necesites un punto."
trail.location.unsupported: "Este sistema no proporciona ubicación. Los campos del informe siguen disponibles."
trail.location.unknown: "Aún no se ha comprobado el permiso."
trail.location.pin: "Punto del mapa: {latitude}, {longitude} · precisión aproximada de {accuracy} m"
trail.location.no_pin: "Este informe no tiene coordenadas."
trail.action.request: "Solicitar acceso a la ubicación"
trail.action.refresh: "Actualizar el estado del permiso"
trail.action.locating: "Obteniendo la ubicación…"
trail.action.add_pin: "Añadir punto al mapa"
trail.error.permission_request: "No se pudo completar la solicitud de acceso a la ubicación. El informe no ha cambiado."
trail.error.permission_refresh: "No se pudo actualizar el estado del permiso. El informe no ha cambiado."
trail.error.permission_required: "Solicita y confirma el acceso a la ubicación antes de añadir un punto."
trail.error.position_denied: "Se denegó la ubicación. Continúa con el tramo asignado o activa el acceso en Ajustes."
trail.error.position_unsupported: "Este sistema no puede devolver una ubicación. Continúa con el tramo asignado."
trail.error.position_timeout: "La ubicación tardó demasiado. Vuelve a intentarlo o continúa sin un punto."
trail.error.position_unavailable: "No se devolvió ninguna posición. Comprueba los servicios de ubicación o continúa sin un punto."
trail.error.position_failed: "El sistema no pudo devolver una posición. El texto del informe no ha cambiado."
{"id":"fission-tabs-1","index":5,"label":"src/lib.rs","value":"src-lib-rs"}
pub mod app;
pub mod state;
mod translations;
use app::TrailReportScreen;
use state::TrailReportState;
use fission::prelude::*;
#[cfg(not(any(target_arch = "wasm32", target_os = "android", target_os = "ios")))]
pub fn run_desktop() -> anyhow::Result<()> {
DesktopApp::<TrailReportState, _>::new(TrailReportScreen)
.with_env(translations::create_env())
.with_sync_env(|state, env| env.locale = state.locale.clone())
.run()
}
#[cfg(any(target_os = "android", target_os = "ios"))]
fn mobile_app() -> MobileApp<TrailReportState, TrailReportScreen> {
let app = MobileApp::<TrailReportState, _>::new(TrailReportScreen)
.with_env(translations::create_env())
.with_sync_env(|state, env| env.locale = state.locale.clone());
#[cfg(all(target_os = "android", debug_assertions))]
let app = app.with_test_control_port(48761);
app
}
#[cfg(any(target_os = "android", target_os = "ios"))]
pub fn run_mobile() -> anyhow::Result<()> { mobile_app().run() }
#[cfg(target_os = "android")]
#[no_mangle]
fn android_main(app_handle: AndroidApp) {
let _ = mobile_app().run_with_android_app(app_handle);
}
#[cfg(target_arch = "wasm32")]
#[wasm_bindgen::prelude::wasm_bindgen(start)]
pub fn run_web() -> Result<(), wasm_bindgen::JsValue> {
console_error_panic_hook::set_once();
WebApp::<TrailReportState, _>::new(TrailReportScreen)
.with_env(translations::create_env())
.with_sync_env(|state, env| env.locale = state.locale.clone())
.run()
.map_err(|error| wasm_bindgen::JsValue::from_str(&error.to_string()))
}
{"id":"fission-tabs-1","index":6,"label":"preview/lib.rs","value":"preview-lib-rs"}
include!("../src/lib.rs");
{"id":"fission-tabs-1"}