rgpui 1.2.1

GUI UI framework
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

use std::future::Future;

use crate::defer;
use crate::{App, AppContext, Global, ReadGlobal, Task};

pub use tokio::runtime::Handle;
pub use tokio::task::JoinError;

/// 初始化 Tokio 包装器，使用带有 2 个工作线程的新 Tokio 运行时。
///
/// 如果需要更多线程（或在 RGPUI 外部访问运行时），可以自行创建运行时
/// 并将 Handle 传递给 `init_from_handle`。
pub fn init(cx: &mut App) {
    let runtime = tokio::runtime::Builder::new_multi_thread()
        // 由于现在有两个执行器，尽量保持占用最小
        .worker_threads(2)
        .enable_all()
        .build()
        .expect("初始化 Tokio 失败");

    let handle = runtime.handle().clone();
    cx.set_global(GlobalTokio {
        owned_runtime: Some(runtime),
        handle,
    });
}

/// 使用 Tokio 运行时句柄初始化包装器。
pub fn init_from_handle(cx: &mut App, handle: tokio::runtime::Handle) {
    cx.set_global(GlobalTokio {
        owned_runtime: None,
        handle,
    });
}

/// 全局 Tokio 运行时包装器
struct GlobalTokio {
    /// 拥有的运行时（如果由本 crate 创建）
    owned_runtime: Option<tokio::runtime::Runtime>,
    /// 运行时句柄
    handle: tokio::runtime::Handle,
}

impl Global for GlobalTokio {}

impl Drop for GlobalTokio {
    /// 销毁时关闭运行时
    fn drop(&mut self) {
        if let Some(runtime) = self.owned_runtime.take() {
            runtime.shutdown_background();
        }
    }
}

/// Tokio 异步任务包装器
pub struct Tokio {}

impl Tokio {
    /// 在 Tokio 线程池上生成给定的 Future，并通过 RGPUI 任务返回结果
    /// 注意：如果 RGPUI 任务被丢弃，Tokio 任务也会被取消
    pub fn spawn<C, Fut, R>(cx: &C, f: Fut) -> Task<Result<R, JoinError>>
    where
        C: AppContext,
        Fut: Future<Output = R> + Send + 'static,
        R: Send + 'static,
    {
        cx.read_global(|tokio: &GlobalTokio, cx| {
            let join_handle = tokio.handle.spawn(f);
            let abort_handle = join_handle.abort_handle();
            let cancel = defer(move || {
                abort_handle.abort();
            });
            cx.background_spawn(async move {
                let result = join_handle.await;
                drop(cancel);
                result
            })
        })
    }

    /// 在 Tokio 线程池上生成给定的 Future，并通过 RGPUI 任务返回 Result
    /// 注意：如果 RGPUI 任务被丢弃，Tokio 任务也会被取消
    pub fn spawn_result<C, Fut, R>(cx: &C, f: Fut) -> Task<anyhow::Result<R>>
    where
        C: AppContext,
        Fut: Future<Output = anyhow::Result<R>> + Send + 'static,
        R: Send + 'static,
    {
        cx.read_global(|tokio: &GlobalTokio, cx| {
            let join_handle = tokio.handle.spawn(f);
            let abort_handle = join_handle.abort_handle();
            let cancel = defer(move || {
                abort_handle.abort();
            });
            cx.background_spawn(async move {
                let result = join_handle.await?;
                drop(cancel);
                result
            })
        })
    }

    /// 获取 Tokio 运行时句柄
    pub fn handle(cx: &App) -> tokio::runtime::Handle {
        GlobalTokio::global(cx).handle.clone()
    }
}