|
1 | 1 | {% if self.include_once_check("CallbackInterfaceRuntime.kt") %}{% include "CallbackInterfaceRuntime.kt" %}{% endif %} |
2 | 2 |
|
3 | | -// Implement the foreign callback handler for {{ interface_name }} |
4 | | -internal class {{ callback_handler_class }} : ForeignCallback { |
5 | | - @Suppress("TooGenericExceptionCaught") |
6 | | - override fun invoke(handle: Handle, method: Int, argsData: Pointer, argsLen: Int, outBuf: RustBufferByReference): Int { |
7 | | - val cb = {{ ffi_converter_name }}.handleMap.get(handle) |
8 | | - return when (method) { |
9 | | - IDX_CALLBACK_FREE -> { |
10 | | - {{ ffi_converter_name }}.handleMap.remove(handle) |
| 3 | +{%- let trait_impl=format!("uniffiCallbackInterface{}", name) %} |
11 | 4 |
|
12 | | - // Successful return |
13 | | - // See docs of ForeignCallback in `uniffi_core/src/ffi/foreigncallbacks.rs` |
14 | | - UNIFFI_CALLBACK_SUCCESS |
15 | | - } |
16 | | - {% for meth in methods.iter() -%} |
17 | | - {% let method_name = format!("invoke_{}", meth.name())|fn_name -%} |
18 | | - {{ loop.index }} -> { |
19 | | - // Call the method, write to outBuf and return a status code |
20 | | - // See docs of ForeignCallback in `uniffi_core/src/ffi/foreigncallbacks.rs` for info |
21 | | - try { |
22 | | - this.{{ method_name }}(cb, argsData, argsLen, outBuf) |
23 | | - } catch (e: Throwable) { |
24 | | - // Unexpected error |
25 | | - try { |
26 | | - // Try to serialize the error into a string |
27 | | - outBuf.setValue({{ Type::String.borrow()|ffi_converter_name }}.lower(e.toString())) |
28 | | - } catch (e: Throwable) { |
29 | | - // If that fails, then it's time to give up and just return |
30 | | - } |
31 | | - UNIFFI_CALLBACK_UNEXPECTED_ERROR |
32 | | - } |
33 | | - } |
34 | | - {% endfor %} |
35 | | - else -> { |
36 | | - // An unexpected error happened. |
37 | | - // See docs of ForeignCallback in `uniffi_core/src/ffi/foreigncallbacks.rs` |
38 | | - try { |
39 | | - // Try to serialize the error into a string |
40 | | - outBuf.setValue({{ Type::String.borrow()|ffi_converter_name }}.lower("Invalid Callback index")) |
41 | | - } catch (e: Throwable) { |
42 | | - // If that fails, then it's time to give up and just return |
43 | | - } |
44 | | - UNIFFI_CALLBACK_UNEXPECTED_ERROR |
| 5 | +// Put the implementation in an object so we don't pollute the top-level namespace |
| 6 | +internal object {{ trait_impl }} { |
| 7 | + {%- for (ffi_callback, meth) in vtable_methods.iter() %} |
| 8 | + internal object {{ meth.name()|var_name }}: {{ ffi_callback.name()|ffi_callback_name }} { |
| 9 | + override fun callback( |
| 10 | + {%- for arg in ffi_callback.arguments() -%} |
| 11 | + {{ arg.name().borrow()|var_name }}: {{ arg.type_().borrow()|ffi_type_name_by_value }}, |
| 12 | + {%- endfor -%} |
| 13 | + {%- if ffi_callback.has_rust_call_status_arg() -%} |
| 14 | + uniffiCallStatus: RustCallStatus, |
| 15 | + {%- endif -%} |
| 16 | + ) |
| 17 | + {%- match ffi_callback.return_type() %} |
| 18 | + {%- when Some(return_type) %}: {{ return_type|ffi_type_name_by_value }}, |
| 19 | + {%- when None %} |
| 20 | + {%- endmatch %} { |
| 21 | + val uniffiObj = {{ ffi_converter_name }}.handleMap.get(uniffiHandle) |
| 22 | + val makeCall = { -> |
| 23 | + uniffiObj.{{ meth.name()|fn_name() }}( |
| 24 | + {%- for arg in meth.arguments() %} |
| 25 | + {{ arg|lift_fn }}({{ arg.name()|var_name }}), |
| 26 | + {%- endfor %} |
| 27 | + ) |
45 | 28 | } |
46 | | - } |
47 | | - } |
48 | 29 |
|
49 | | - {% for meth in methods.iter() -%} |
50 | | - {% let method_name = format!("invoke_{}", meth.name())|fn_name %} |
51 | | - @Suppress("UNUSED_PARAMETER") |
52 | | - private fun {{ method_name }}(kotlinCallbackInterface: {{ interface_name }}, argsData: Pointer, argsLen: Int, outBuf: RustBufferByReference): Int { |
53 | | - {%- if meth.arguments().len() > 0 %} |
54 | | - val argsBuf = argsData.getByteBuffer(0, argsLen.toLong()).also { |
55 | | - it.order(ByteOrder.BIG_ENDIAN) |
56 | | - } |
57 | | - {%- endif %} |
| 30 | + {%- match meth.return_type() %} |
| 31 | + {%- when Some(return_type) %} |
| 32 | + val writeReturn = { value: {{ return_type|type_name(ci) }} -> uniffiOutReturn.setValue({{ return_type|lower_fn }}(value)) } |
| 33 | + {%- when None %} |
| 34 | + val writeReturn = { _: Unit -> Unit } |
| 35 | + {%- endmatch %} |
58 | 36 |
|
59 | | - {%- match meth.return_type() %} |
60 | | - {%- when Some with (return_type) %} |
61 | | - fun makeCall() : Int { |
62 | | - val returnValue = kotlinCallbackInterface.{{ meth.name()|fn_name }}( |
63 | | - {%- for arg in meth.arguments() %} |
64 | | - {{ arg|read_fn }}(argsBuf) |
65 | | - {% if !loop.last %}, {% endif %} |
66 | | - {%- endfor %} |
67 | | - ) |
68 | | - outBuf.setValue({{ return_type|ffi_converter_name }}.lowerIntoRustBuffer(returnValue)) |
69 | | - return UNIFFI_CALLBACK_SUCCESS |
70 | | - } |
71 | | - {%- when None %} |
72 | | - fun makeCall() : Int { |
73 | | - kotlinCallbackInterface.{{ meth.name()|fn_name }}( |
74 | | - {%- for arg in meth.arguments() %} |
75 | | - {{ arg|read_fn }}(argsBuf) |
76 | | - {%- if !loop.last %}, {% endif %} |
77 | | - {%- endfor %} |
| 37 | + {%- match meth.throws_type() %} |
| 38 | + {%- when None %} |
| 39 | + uniffiTraitInterfaceCall(uniffiCallStatus, makeCall, writeReturn) |
| 40 | + {%- when Some(error_type) %} |
| 41 | + uniffiTraitInterfaceCallWithError( |
| 42 | + uniffiCallStatus, |
| 43 | + makeCall, |
| 44 | + writeReturn, |
| 45 | + { e: {{error_type|type_name(ci) }} -> {{ error_type|lower_fn }}(e) } |
78 | 46 | ) |
79 | | - return UNIFFI_CALLBACK_SUCCESS |
| 47 | + {%- endmatch %} |
80 | 48 | } |
81 | | - {%- endmatch %} |
| 49 | + } |
| 50 | + {%- endfor %} |
82 | 51 |
|
83 | | - {%- match meth.throws_type() %} |
84 | | - {%- when None %} |
85 | | - fun makeCallAndHandleError() : Int = makeCall() |
86 | | - {%- when Some(error_type) %} |
87 | | - fun makeCallAndHandleError() : Int = try { |
88 | | - makeCall() |
89 | | - } catch (e: {{ error_type|type_name(ci) }}) { |
90 | | - // Expected error, serialize it into outBuf |
91 | | - outBuf.setValue({{ error_type|ffi_converter_name }}.lowerIntoRustBuffer(e)) |
92 | | - UNIFFI_CALLBACK_ERROR |
| 52 | + internal object uniffiFree: {{ "CallbackInterfaceFree"|ffi_callback_name }} { |
| 53 | + override fun callback(handle: Long) { |
| 54 | + {{ ffi_converter_name }}.handleMap.remove(handle) |
93 | 55 | } |
94 | | - {%- endmatch %} |
95 | | - |
96 | | - return makeCallAndHandleError() |
97 | 56 | } |
98 | | - {% endfor %} |
| 57 | + |
| 58 | + internal var vtable = {{ vtable|ffi_type_name_by_value }}( |
| 59 | + {%- for (ffi_callback, meth) in vtable_methods.iter() %} |
| 60 | + {{ meth.name()|var_name() }}, |
| 61 | + {%- endfor %} |
| 62 | + uniffiFree |
| 63 | + ) |
99 | 64 |
|
100 | 65 | // Registers the foreign callback with the Rust side. |
101 | 66 | // This method is generated for each callback interface. |
102 | 67 | internal fun register(lib: _UniFFILib) { |
103 | | - lib.{{ ffi_init_callback.name() }}(this) |
| 68 | + lib.{{ ffi_init_callback.name() }}(vtable) |
104 | 69 | } |
105 | 70 | } |
106 | | - |
107 | | -internal val {{ callback_handler_obj }} = {{ callback_handler_class }}() |
0 commit comments