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
108
109
110
111
112
113
114
115
116
117
|
// Async return type handlers
internal const val UNIFFI_RUST_FUTURE_POLL_READY = 0.toByte()
internal const val UNIFFI_RUST_FUTURE_POLL_MAYBE_READY = 1.toByte()
internal val uniffiContinuationHandleMap = UniffiHandleMap<CancellableContinuation<Byte>>()
// FFI type for Rust future continuations
internal object uniffiRustFutureContinuationCallbackImpl: UniffiRustFutureContinuationCallback {
override fun callback(data: Long, pollResult: Byte) {
uniffiContinuationHandleMap.remove(data).resume(pollResult)
}
}
internal suspend fun<T, F, E: Exception> uniffiRustCallAsync(
rustFuture: Long,
pollFunc: (Long, UniffiRustFutureContinuationCallback, Long) -> Unit,
completeFunc: (Long, UniffiRustCallStatus) -> F,
freeFunc: (Long) -> Unit,
liftFunc: (F) -> T,
errorHandler: UniffiRustCallStatusErrorHandler<E>
): T {
try {
do {
val pollResult = suspendCancellableCoroutine<Byte> { continuation ->
pollFunc(
rustFuture,
uniffiRustFutureContinuationCallbackImpl,
uniffiContinuationHandleMap.insert(continuation)
)
}
} while (pollResult != UNIFFI_RUST_FUTURE_POLL_READY);
return liftFunc(
uniffiRustCallWithError(errorHandler, { status -> completeFunc(rustFuture, status) })
)
} finally {
freeFunc(rustFuture)
}
}
{%- if ci.has_async_callback_interface_definition() %}
internal inline fun<T> uniffiTraitInterfaceCallAsync(
crossinline makeCall: suspend () -> T,
crossinline handleSuccess: (T) -> Unit,
crossinline handleError: (UniffiRustCallStatus.ByValue) -> Unit,
): UniffiForeignFuture {
// Using `GlobalScope` is labeled as a "delicate API" and generally discouraged in Kotlin programs, since it breaks structured concurrency.
// However, our parent task is a Rust future, so we're going to need to break structure concurrency in any case.
//
// Uniffi does its best to support structured concurrency across the FFI.
// If the Rust future is dropped, `uniffiForeignFutureFreeImpl` is called, which will cancel the Kotlin coroutine if it's still running.
@OptIn(DelicateCoroutinesApi::class)
val job = GlobalScope.launch {
try {
handleSuccess(makeCall())
} catch(e: Exception) {
handleError(
UniffiRustCallStatus.create(
UNIFFI_CALL_UNEXPECTED_ERROR,
{{ Type::String.borrow()|lower_fn }}(e.toString()),
)
)
}
}
val handle = uniffiForeignFutureHandleMap.insert(job)
return UniffiForeignFuture(handle, uniffiForeignFutureFreeImpl)
}
internal inline fun<T, reified E: Throwable> uniffiTraitInterfaceCallAsyncWithError(
crossinline makeCall: suspend () -> T,
crossinline handleSuccess: (T) -> Unit,
crossinline handleError: (UniffiRustCallStatus.ByValue) -> Unit,
crossinline lowerError: (E) -> RustBuffer.ByValue,
): UniffiForeignFuture {
// See uniffiTraitInterfaceCallAsync for details on `DelicateCoroutinesApi`
@OptIn(DelicateCoroutinesApi::class)
val job = GlobalScope.launch {
try {
handleSuccess(makeCall())
} catch(e: Exception) {
if (e is E) {
handleError(
UniffiRustCallStatus.create(
UNIFFI_CALL_ERROR,
lowerError(e),
)
)
} else {
handleError(
UniffiRustCallStatus.create(
UNIFFI_CALL_UNEXPECTED_ERROR,
{{ Type::String.borrow()|lower_fn }}(e.toString()),
)
)
}
}
}
val handle = uniffiForeignFutureHandleMap.insert(job)
return UniffiForeignFuture(handle, uniffiForeignFutureFreeImpl)
}
internal val uniffiForeignFutureHandleMap = UniffiHandleMap<Job>()
internal object uniffiForeignFutureFreeImpl: UniffiForeignFutureFree {
override fun callback(handle: Long) {
val job = uniffiForeignFutureHandleMap.remove(handle)
if (!job.isCompleted) {
job.cancel()
}
}
}
// For testing
public fun uniffiForeignFutureHandleCount() = uniffiForeignFutureHandleMap.size
{%- endif %}
|
