The screen starts empty. Completion records a trimmed task, clears its draft and sets feedback pending before queuing any host work. A blank submission or a second submission whilst pending changes nothing. Extracting that small rule makes its invariant testable without constructing a window or pretending a provider ran.
The provider check below deliberately uses MemoryHapticHost and UnsupportedHapticHost inside #[cfg(test)]. It establishes their contract, not the effect dispatcher's integration or physical feedback. Normal launches and this browser preview still use their actual platform providers. The production callbacks bind unit actions and decode the actual host input.
{"id":"fission-tabs-1","tabs":[{"index":0,"label":"src/app.rs","value":"src-app-rs"},{"index":1,"label":"src/app/state.rs","value":"src-app-state-rs"},{"index":2,"label":"src/app/screen.rs","value":"src-app-screen-rs"},{"index":3,"label":"src/i18n.rs","value":"src-i18n-rs"},{"index":4,"label":"src/lib.rs","value":"src-lib-rs"},{"index":5,"label":"preview/lib.rs","value":"preview-lib-rs"},{"index":6,"label":"i18n/en-US.yaml","value":"i18n-en-us-yaml"},{"index":7,"label":"i18n/es-ES.yaml","value":"i18n-es-es-yaml"}]}
{"id":"fission-tabs-1","index":0,"label":"src/app.rs","value":"src-app-rs"}
pub mod screen;
pub mod state;
pub use screen::TaskCompletionScreen;
pub use state::TaskState;
{"id":"fission-tabs-1","index":1,"label":"src/app/state.rs","value":"src-app-state-rs"}
use fission::prelude::*;
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub enum Feedback {
#[default]
Idle,
Pending,
Accepted,
Unavailable,
InvalidResult,
}
impl Feedback {
pub fn message_key(&self) -> &'static str {
match self {
Self::Idle => "feedback.optional",
Self::Pending => "feedback.pending",
Self::Accepted => "feedback.accepted",
Self::Unavailable => "feedback.unavailable",
Self::InvalidResult => "feedback.invalid",
}
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct TaskState {
pub draft: String,
pub completed: Option<String>,
pub feedback: Feedback,
pub locale: Locale,
}
impl Default for TaskState {
fn default() -> Self {
Self {
draft: String::new(),
completed: None,
feedback: Feedback::Idle,
locale: Locale::from("en-US"),
}
}
}
impl GlobalState for TaskState {}
pub fn record_completion(state: &mut TaskState) -> bool {
if state.feedback == Feedback::Pending || state.draft.trim().is_empty() {
return false;
}
state.completed = Some(state.draft.trim().to_owned());
state.draft.clear();
state.feedback = Feedback::Pending;
true
}
pub fn complete_task(state: &mut TaskState, cx: &mut ReducerContext<TaskState>) {
if !record_completion(state) {
return;
}
let ok = cx
.effects
.bind(HapticAccepted, reduce_with!(on_haptic_accepted));
let err = cx
.effects
.bind(HapticUnavailable, reduce_with!(on_haptic_unavailable));
cx.effects
.haptics()
.notification(HapticNotificationRequest {
kind: HapticNotificationKind::Success,
})
.on_ok(ok)
.on_err(err);
}
#[fission_reducer(HapticAccepted)]
fn on_haptic_accepted(state: &mut TaskState, cx: &mut ReducerContext<TaskState>) {
state.feedback = if cx.input.capability_ok(HAPTIC_NOTIFICATION).is_some() {
Feedback::Accepted
} else {
Feedback::InvalidResult
};
}
#[fission_reducer(HapticUnavailable)]
fn on_haptic_unavailable(state: &mut TaskState, cx: &mut ReducerContext<TaskState>) {
state.feedback = if cx.input.capability_error(HAPTIC_NOTIFICATION).is_some() {
Feedback::Unavailable
} else {
Feedback::InvalidResult
};
}
#[cfg(all(test, not(target_arch = "wasm32")))]
mod tests {
use super::*;
#[test]
fn completion_records_trimmed_input_before_feedback() {
let mut state = TaskState::default();
state.draft = " Check the fire exit ".into();
assert!(record_completion(&mut state));
assert_eq!(state.completed.as_deref(), Some("Check the fire exit"));
assert!(state.draft.is_empty());
assert_eq!(state.feedback, Feedback::Pending);
}
#[test]
fn blank_and_busy_submissions_preserve_previous_completion() {
let mut state = TaskState::default();
state.completed = Some("Check the fire exit".into());
state.draft = " ".into();
assert!(!record_completion(&mut state));
state.feedback = Feedback::Pending;
state.draft = "Check the loading bay".into();
assert!(!record_completion(&mut state));
assert_eq!(state.completed.as_deref(), Some("Check the fire exit"));
assert_eq!(state.draft, "Check the loading bay");
}
#[test]
fn test_providers_distinguish_acceptance_from_unavailability() {
let memory = MemoryHapticHost::default();
let request = HapticNotificationRequest {
kind: HapticNotificationKind::Success,
};
assert!(memory.notification(request).is_ok());
assert_eq!(memory.calls(), vec!["notification".to_owned()]);
assert!(UnsupportedHapticHost
.notification(HapticNotificationRequest {
kind: HapticNotificationKind::Success,
})
.is_err());
}
}
{"id":"fission-tabs-1","index":2,"label":"src/app/screen.rs","value":"src-app-screen-rs"}
use super::state::{complete_task, Feedback, TaskState};
use fission::prelude::*;
fission_component! {
pub TaskCompletionScreen<TaskState> {}
view(_screen, state, cx) {
let tokens = &cx.view.env().theme.tokens;
let pending = state.feedback == Feedback::Pending;
} => SafeArea(
child: Scroll(
child: Container(
Column(gap: tokens.spacing.m, children: [
Text(cx.tr("task.title"))
.size(tokens.typography.heading2_size),
Text(cx.tr("task.explanation"))
.color(tokens.colors.text_secondary),
Row(gap: tokens.spacing.s, children: [
Button(
child: Text(cx.tr("language.english")),
key: "english",
on_press: reduce { state.locale = Locale::from("en-US"); },
),
Button(
child: Text(cx.tr("language.spanish")),
key: "spanish",
on_press: reduce { state.locale = Locale::from("es-ES"); },
),
]),
FormControl(
label: Some(cx.tr("task.label")),
required: true,
child: TextInput(
value: state.draft.clone(),
bind(on_input): to(state.draft),
placeholder: Some(TextContent::Key("task.placeholder".into())),
semantics_identifier: Some("task.draft".into()),
),
),
Button(
child: Text(cx.tr("task.complete")),
key: "complete-task",
disabled: pending || state.draft.trim().is_empty(),
on_press: reduce { complete_task(state, cx); },
)
.semantics_identifier("task.complete"),
if let Some(task) = &state.completed {
Text(cx.tr("task.completed").replace("{task}", task))
},
if pending {
Spinner(
motion: Some(SpinnerMotion::Default),
label: Some(cx.tr("feedback.pending")),
)
},
Text(cx.tr(state.feedback.message_key())),
Text(cx.tr("task.persistence"))
.color(tokens.colors.text_secondary),
]),
)
.padding_all(tokens.spacing.l)
.bg(tokens.colors.surface),
),
)
}
{"id":"fission-tabs-1","index":3,"label":"src/i18n.rs","value":"src-i18n-rs"}
use fission::i18n::{Locale, TranslationBundle};
use fission::prelude::*;
use std::collections::HashMap;
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 task translations");
env.i18n.add_bundle(TranslationBundle {
locale: Locale::from(locale),
messages,
});
}
env
}
pub fn sync_env(state: &crate::app::TaskState, env: &mut Env) {
env.locale = state.locale.clone();
}
{"id":"fission-tabs-1","index":4,"label":"src/lib.rs","value":"src-lib-rs"}
pub mod app;
mod i18n;
use app::{TaskCompletionScreen, TaskState};
use fission::prelude::*;
#[cfg(not(any(target_arch = "wasm32", target_os = "android", target_os = "ios")))]
pub fn run_desktop() -> anyhow::Result<()> {
DesktopApp::<TaskState, _>::new(TaskCompletionScreen)
.with_env(i18n::create_env())
.with_sync_env(i18n::sync_env)
.run()
}
#[cfg(any(target_os = "android", target_os = "ios"))]
pub fn run_mobile() -> anyhow::Result<()> {
MobileApp::<TaskState, _>::new(TaskCompletionScreen)
.with_env(i18n::create_env())
.with_sync_env(i18n::sync_env)
.run()
}
#[cfg(target_os = "android")]
#[no_mangle]
fn android_main(app_handle: AndroidApp) {
let _ = MobileApp::<TaskState, _>::new(TaskCompletionScreen)
.with_env(i18n::create_env())
.with_sync_env(i18n::sync_env)
.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::<TaskState, _>::new(TaskCompletionScreen)
.with_env(i18n::create_env())
.with_sync_env(i18n::sync_env)
.run()
.map_err(|error| wasm_bindgen::JsValue::from_str(&error.to_string()))
}
{"id":"fission-tabs-1","index":5,"label":"preview/lib.rs","value":"preview-lib-rs"}
mod app;
mod i18n;
use fission::prelude::*;
use wasm_bindgen::prelude::*;
#[wasm_bindgen(start)]
pub fn run() -> Result<(), JsValue> {
console_error_panic_hook::set_once();
WebApp::<app::TaskState, _>::new(app::TaskCompletionScreen)
.with_env(i18n::create_env())
.with_sync_env(i18n::sync_env)
.mount("#fission-web-mount")
.run()
.map_err(|error| JsValue::from_str(&error.to_string()))
}
{"id":"fission-tabs-1","index":6,"label":"i18n/en-US.yaml","value":"i18n-en-us-yaml"}
task.title: "Finish a task"
task.explanation: "Enter a task you have finished. Its completion stays visible even when haptic feedback is unavailable."
task.label: "Completed task"
task.placeholder: "For example, send the supplier invoice"
task.complete: "Mark complete"
task.completed: "Completed: {task}"
task.persistence: "Tasks are kept in memory for this session. This example does not save them."
language.english: "English"
language.spanish: "Español"
feedback.optional: "Haptic feedback is an optional confirmation."
feedback.pending: "Task completed. Waiting for optional haptic feedback…"
feedback.accepted: "Task completed. The host accepted the haptic request."
feedback.unavailable: "Task completed. Haptic feedback is unavailable on this host."
feedback.invalid: "Task completed. The host returned an unexpected feedback result."
{"id":"fission-tabs-1","index":7,"label":"i18n/es-ES.yaml","value":"i18n-es-es-yaml"}
task.title: "Finaliza una tarea"
task.explanation: "Escribe una tarea que hayas terminado. La confirmación permanece visible aunque la respuesta háptica no esté disponible."
task.label: "Tarea terminada"
task.placeholder: "Por ejemplo, enviar la factura al proveedor"
task.complete: "Marcar como terminada"
task.completed: "Terminada: {task}"
task.persistence: "Las tareas se conservan en memoria durante esta sesión. Este ejemplo no las guarda."
language.english: "Inglés"
language.spanish: "Español"
feedback.optional: "La respuesta háptica es una confirmación opcional."
feedback.pending: "Tarea terminada. Esperando la respuesta háptica opcional…"
feedback.accepted: "Tarea terminada. El host ha aceptado la solicitud háptica."
feedback.unavailable: "Tarea terminada. La respuesta háptica no está disponible en este host."
feedback.invalid: "Tarea terminada. El host ha devuelto un resultado inesperado."
{"id":"fission-tabs-1"}