状态

type TypeIdMap = HashMap<TypeId, Box<dyn Any + Sync + Send>, BuildHasherDefault<IdentHash>>;

/// The Tauri state manager.
// TODO: make private for v3
#[derive(Debug)]
pub struct StateManager {
  map: Mutex<TypeIdMap>,
}

  pub(crate) fn set<T: Send + Sync + 'static>(&self, state: T) -> bool {
    let mut map = self.map.lock().unwrap();
    let type_id = TypeId::of::<T>();
    let already_set = map.contains_key(&type_id);
    if !already_set {
      let state = Box::new(state) as Box<dyn Any + Sync + Send>;
      map.insert(type_id, state);
    }
    !already_set
  }

pub struct State<'r, T>(&'r T);

  pub fn try_get<T: 'static>(&self) -> Option<State<'_, T>> {
    let map = self.map.lock().unwrap();
    let type_id = TypeId::of::<T>();
    let state = map.get(&type_id)?;
    let value = state
      .downcast_ref::<T>()
      .expect("the type of the key should be same as the type of the value");
    // SAFETY: We ensure the lifetime of `value` is the same as [StateManager] and `value` will not be mutated/moved.
    let v_ref = unsafe { &*(value as *const T) };
    Some(State(v_ref))
  }

struct Counter(AtomicU32);

#[tauri::command]
fn sync_cmd(counter: State<'_, Counter>) -> u32 {
  log("app command sync_cmd");
  counter.0.fetch_add(1, Ordering::SeqCst) + 1
}

  fn manage<T>(&self, state: T) -> bool
  where
    T: Send + Sync + 'static,
  {
    self.manager().state.set(state)
  }

  pub fn manage<T>(self, state: T) -> Self
  where
    T: Send + Sync + 'static,
  {
    let type_name = std::any::type_name::<T>();
    assert!(
      self.state.set(state),
      "state for type '{type_name}' is already being managed",
    );
    self
  }

      log(format!(
        "manage(Counter) again -> {}, state = {}",
        app.manage(Counter(AtomicU32::new(9))),
        app.state::<Counter>().0.load(Ordering::SeqCst)
      ));

    0ms [main] main

thread 'main' (2368726) panicked at ~/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tauri-2.12.5/src/app.rs:2060:5:
state for type 'app_life::Counter' is already being managed
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
exit=101

impl<'r, 'de: 'r, T: Send + Sync + 'static, R: Runtime> CommandArg<'de, R> for State<'r, T> {
  /// Grabs the [`State`] from the [`CommandItem`]. This will never fail.
  fn from_command(command: CommandItem<'de, R>) -> Result<Self, InvokeError> {
    command.message.webview_ref().try_state().ok_or_else(|| {
      InvokeError::from_anyhow(anyhow::anyhow!(
        "state not managed for field `{}` on command `{}`. You must call `.manage()` before using this command",
        command.key, command.name
      ))
    })
  }
}

struct Missing;

#[tauri::command]
fn need_state(_m: State<'_, Missing>) {}

need_state err: state not managed for field `m` on command `need_state`. You must call `.manage()` before using this command

pub trait Resource: Any + 'static + Send + Sync {
  fn name(&self) -> Cow<'_, str> {
    type_name::<Self>().into()
  }

  fn close(self: Arc<Self>) {}
}

pub type ResourceId = u32;

#[derive(Default)]
pub struct ResourceTable {
  index: BTreeMap<ResourceId, Arc<dyn Resource>>,
}

#[command(root = "crate")]
fn close<R: Runtime>(webview: Webview<R>, rid: ResourceId) -> crate::Result<()> {
  let mut result = webview.resources_table().close(rid);
  if result.is_err() {
    result = webview.window().resources_table().close(rid);
    if result.is_err() {
      result = webview.app_handle().resources_table().close(rid);
    }
  }
  result
}

struct Res(&'static str);

impl tauri::Resource for Res {
  fn close(self: std::sync::Arc<Self>) {
    log(format!("Resource::close {} (strong_count={})", self.0, std::sync::Arc::strong_count(&self)));
  }
}

impl Drop for Res {
  fn drop(&mut self) {
    log(format!("drop Res {}", self.0));
  }
}

#[tauri::command]
fn open_res(webview: tauri::Webview) -> tauri::ResourceId {
  let rid = webview.resources_table().add(Res("db-conn"));
  log(format!("open_res -> rid {rid}"));
  rid
}

  const rid = await I.invoke('open_res');
  await t(`plugin:resources|close rid=${rid}`, () => I.invoke('plugin:resources|close', { rid }));
  await t(`plugin:resources|close again`, () => I.invoke('plugin:resources|close', { rid }));

 1024ms [main] open_res -> rid 1076734987
 1025ms [main] Resource::close db-conn (strong_count=1)
 1025ms [main] drop Res db-conn
...
plugin:resources|close rid=1076734987 ok: null
plugin:resources|close again err: The resource id 1076734987 is invalid.

  379ms [main] manage(Counter) again -> false, state = 0