Get started
Introduction
Installation
Your first app
Tutorials
Fission tutorials
Handle Android location permission denials in a trail report app
Core concepts
Components
State and effects
Protected routes
Server-side rendering
Styling
Testing
Deployment
Reference
API reference
Cookbook
Fission 0.16.0
Documentation version
Read the changelog →

Handle Android location permission denials in a trail report app

Keep a trail report editable when location is denied. Request access only for an optional pin and read the actual permission and position results.
Android

What you will build

Draft a trail hazard report that works without coordinates, and add an optional pin only after location access has been confirmed.
Preserve the segment and observation through denial and position failures
Separate requesting permission from checking the answer after Android's prompt
Decode typed permission, position and error results rather than placeholder action data
Check coarse access, revocation and later settings changes without requiring background location
A trail report needs a recognisable segment and a useful description. Coordinates can help the next crew find a fallen tree, but requiring them would make the whole report depend on permission, location services and a returned position.
Here, those are separate concerns. The report starts empty and remains editable without location. The user requests foreground access only when a map pin is useful, checks the permission after the Android prompt, and then explicitly asks for a position. Nothing is saved or sent to a service in this example.
Start from a new project (optional)

Create the Android project

Use SDK/NDK setup before launching on an emulator or a phone.
cargo install cargo-fission
fission init juniper-trail-reports
cd juniper-trail-reports
fission add-target android --project-dir .
fission add-capability geolocation --project-dir .
cargo add serde_yaml
Keep the generated src/main.rs. Shared state owns the draft and confirmed permission; the shell only configures and launches the same application. Locale is also state, mirrored into Env for both targets rather than selected independently by each widget.

Run the finished example

fission run --target android --project-dir .

1. Preserve the report whilst permission changes

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"}
Enter a segment and observation before trying location. Grant, denial and failure must leave both fields intact. A newly confirmed denial removes the old pin rather than presenting it as current access. The preview uses the actual browser geolocation provider, not a fabricated test position; browser consent and secure-context requirements still apply.
Show the app preview
Hide the app preview

2. Verify denial and a later settings change

cargo test
fission doctor android --project-dir .
adb devices -l
fission run --target android --device <adb-serial> --project-dir .
fission test --target android --project-dir .
fission build --target android --project-dir . --release
Begin with this app's location permission disabled in Android Settings. Enter report text, request access and decline. After the dialog closes, refresh the status: adding a pin should remain unavailable whilst the report remains editable. Grant foreground access, recheck, then request the position. Repeat after revoking access; a failed lookup must not erase the report or silently submit its previous pin.
Permission and position accuracy are different facts. Android can grant coarse access, and the returned accuracy is part of the result, not a fixed promise made by the interface. The one-shot provider may return an eligible recent position; this is not continuous tracking. Do not log a user's coordinates to diagnose button behaviour.
Inspect the generated manifest and retain only permissions the feature requires. A one-time map pin does not justify background location. Emulator tests can exercise the prompt and supplied emulator position; a physical walk and real location-service conditions are separate checks. No build command proves those outcomes.
Android's runtime permission guidance explains the OS policy. The Geolocation reference defines Fission's portable request and result types.