mirror of
https://github.com/tauri-apps/tauri.git
synced 2024-12-14 21:21:44 +03:00
260 lines
6.6 KiB
Rust
260 lines
6.6 KiB
Rust
// Copyright 2019-2022 Tauri Programme within The Commons Conservancy
|
|
// SPDX-License-Identifier: Apache-2.0
|
|
// SPDX-License-Identifier: MIT
|
|
|
|
#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
|
|
|
|
// we move some basic commands to a separate module just to show it works
|
|
mod commands;
|
|
use commands::{cmd, invoke, message, resolver};
|
|
|
|
use serde::Deserialize;
|
|
use tauri::{command, State, Window};
|
|
|
|
#[derive(Debug)]
|
|
pub struct MyState {
|
|
#[allow(dead_code)]
|
|
value: u64,
|
|
#[allow(dead_code)]
|
|
label: String,
|
|
}
|
|
|
|
#[derive(Debug, serde::Serialize)]
|
|
enum MyError {
|
|
FooError,
|
|
}
|
|
|
|
// ------------------------ Commands using Window ------------------------
|
|
#[command]
|
|
fn window_label(window: Window) {
|
|
println!("window label: {}", window.label());
|
|
}
|
|
|
|
// Async commands
|
|
|
|
#[command]
|
|
async fn async_simple_command(the_argument: String) {
|
|
println!("{the_argument}");
|
|
}
|
|
|
|
#[command(rename_all = "snake_case")]
|
|
async fn async_simple_command_snake(the_argument: String) {
|
|
println!("{the_argument}");
|
|
}
|
|
|
|
#[command]
|
|
async fn async_stateful_command(
|
|
the_argument: Option<String>,
|
|
state: State<'_, MyState>,
|
|
) -> Result<(), ()> {
|
|
println!("{:?} {:?}", the_argument, state.inner());
|
|
Ok(())
|
|
}
|
|
// ------------------------ Raw future commands ------------------------
|
|
|
|
#[command(async)]
|
|
fn future_simple_command(the_argument: String) -> impl std::future::Future<Output = ()> {
|
|
println!("{the_argument}");
|
|
std::future::ready(())
|
|
}
|
|
|
|
#[command(async)]
|
|
fn future_simple_command_with_return(
|
|
the_argument: String,
|
|
) -> impl std::future::Future<Output = String> {
|
|
println!("{the_argument}");
|
|
std::future::ready(the_argument)
|
|
}
|
|
|
|
#[command(async)]
|
|
fn future_simple_command_with_result(
|
|
the_argument: String,
|
|
) -> impl std::future::Future<Output = Result<String, ()>> {
|
|
println!("{the_argument}");
|
|
std::future::ready(Ok(the_argument))
|
|
}
|
|
|
|
#[command(async)]
|
|
fn force_async(the_argument: String) -> String {
|
|
the_argument
|
|
}
|
|
|
|
#[command(async)]
|
|
fn force_async_with_result(the_argument: &str) -> Result<&str, MyError> {
|
|
(!the_argument.is_empty())
|
|
.then(|| the_argument)
|
|
.ok_or(MyError::FooError)
|
|
}
|
|
|
|
// ------------------------ Raw future commands - snake_case ------------------------
|
|
|
|
#[command(async, rename_all = "snake_case")]
|
|
fn future_simple_command_snake(the_argument: String) -> impl std::future::Future<Output = ()> {
|
|
println!("{the_argument}");
|
|
std::future::ready(())
|
|
}
|
|
|
|
#[command(async, rename_all = "snake_case")]
|
|
fn future_simple_command_with_return_snake(
|
|
the_argument: String,
|
|
) -> impl std::future::Future<Output = String> {
|
|
println!("{the_argument}");
|
|
std::future::ready(the_argument)
|
|
}
|
|
|
|
#[command(async, rename_all = "snake_case")]
|
|
fn future_simple_command_with_result_snake(
|
|
the_argument: String,
|
|
) -> impl std::future::Future<Output = Result<String, ()>> {
|
|
println!("{the_argument}");
|
|
std::future::ready(Ok(the_argument))
|
|
}
|
|
|
|
#[command(async, rename_all = "snake_case")]
|
|
fn force_async_snake(the_argument: String) -> String {
|
|
the_argument
|
|
}
|
|
|
|
#[command(rename_all = "snake_case", async)]
|
|
fn force_async_with_result_snake(the_argument: &str) -> Result<&str, MyError> {
|
|
(!the_argument.is_empty())
|
|
.then(|| the_argument)
|
|
.ok_or(MyError::FooError)
|
|
}
|
|
|
|
// ------------------------ Commands returning Result ------------------------
|
|
|
|
#[command]
|
|
fn simple_command_with_result(the_argument: String) -> Result<String, MyError> {
|
|
println!("{the_argument}");
|
|
(!the_argument.is_empty())
|
|
.then(|| the_argument)
|
|
.ok_or(MyError::FooError)
|
|
}
|
|
|
|
#[command]
|
|
fn stateful_command_with_result(
|
|
the_argument: Option<String>,
|
|
state: State<'_, MyState>,
|
|
) -> Result<String, MyError> {
|
|
println!("{:?} {:?}", the_argument, state.inner());
|
|
dbg!(the_argument.ok_or(MyError::FooError))
|
|
}
|
|
|
|
// ------------------------ Commands returning Result - snake_case ------------------------
|
|
|
|
#[command(rename_all = "snake_case")]
|
|
fn simple_command_with_result_snake(the_argument: String) -> Result<String, MyError> {
|
|
println!("{the_argument}");
|
|
(!the_argument.is_empty())
|
|
.then(|| the_argument)
|
|
.ok_or(MyError::FooError)
|
|
}
|
|
|
|
#[command(rename_all = "snake_case")]
|
|
fn stateful_command_with_result_snake(
|
|
the_argument: Option<String>,
|
|
state: State<'_, MyState>,
|
|
) -> Result<String, MyError> {
|
|
println!("{:?} {:?}", the_argument, state.inner());
|
|
dbg!(the_argument.ok_or(MyError::FooError))
|
|
}
|
|
|
|
// Async commands
|
|
|
|
#[command]
|
|
async fn async_simple_command_with_result(the_argument: String) -> Result<String, MyError> {
|
|
println!("{the_argument}");
|
|
Ok(the_argument)
|
|
}
|
|
|
|
#[command]
|
|
async fn async_stateful_command_with_result(
|
|
the_argument: Option<String>,
|
|
state: State<'_, MyState>,
|
|
) -> Result<String, MyError> {
|
|
println!("{:?} {:?}", the_argument, state.inner());
|
|
Ok(the_argument.unwrap_or_default())
|
|
}
|
|
|
|
// Non-Ident command function arguments
|
|
|
|
#[command]
|
|
fn command_arguments_wild(_: Window) {
|
|
println!("we saw the wildcard!")
|
|
}
|
|
|
|
#[derive(Deserialize)]
|
|
struct Person<'a> {
|
|
name: &'a str,
|
|
age: u8,
|
|
}
|
|
|
|
#[command]
|
|
fn command_arguments_struct(Person { name, age }: Person<'_>) {
|
|
println!("received person struct with name: {name} | age: {age}")
|
|
}
|
|
|
|
#[derive(Deserialize)]
|
|
struct InlinePerson<'a>(&'a str, u8);
|
|
|
|
#[command]
|
|
fn command_arguments_tuple_struct(InlinePerson(name, age): InlinePerson<'_>) {
|
|
println!("received person tuple with name: {name} | age: {age}")
|
|
}
|
|
|
|
#[command]
|
|
fn borrow_cmd(the_argument: &str) -> &str {
|
|
the_argument
|
|
}
|
|
|
|
#[command]
|
|
fn borrow_cmd_async(the_argument: &str) -> &str {
|
|
the_argument
|
|
}
|
|
|
|
fn main() {
|
|
tauri::Builder::default()
|
|
.manage(MyState {
|
|
value: 0,
|
|
label: "Tauri!".into(),
|
|
})
|
|
.invoke_handler(tauri::generate_handler![
|
|
borrow_cmd,
|
|
borrow_cmd_async,
|
|
window_label,
|
|
force_async,
|
|
force_async_with_result,
|
|
commands::simple_command,
|
|
commands::stateful_command,
|
|
cmd,
|
|
invoke,
|
|
message,
|
|
resolver,
|
|
async_simple_command,
|
|
future_simple_command,
|
|
async_stateful_command,
|
|
command_arguments_wild,
|
|
command_arguments_struct,
|
|
simple_command_with_result,
|
|
async_simple_command_snake,
|
|
future_simple_command_snake,
|
|
future_simple_command_with_return_snake,
|
|
future_simple_command_with_result_snake,
|
|
force_async_snake,
|
|
force_async_with_result_snake,
|
|
simple_command_with_result_snake,
|
|
stateful_command_with_result_snake,
|
|
stateful_command_with_result,
|
|
command_arguments_tuple_struct,
|
|
async_simple_command_with_result,
|
|
future_simple_command_with_return,
|
|
future_simple_command_with_result,
|
|
async_stateful_command_with_result,
|
|
])
|
|
.run(tauri::generate_context!(
|
|
"../../examples/commands/tauri.conf.json"
|
|
))
|
|
.expect("error while running tauri application");
|
|
}
|