1191 lines
38 KiB
Dart
1191 lines
38 KiB
Dart
// This file is automatically generated, so please do not edit it.
|
|
// @generated by `flutter_rust_bridge`@ 2.13.0.
|
|
|
|
// ignore_for_file: unused_import, unused_element, unnecessary_import, duplicate_ignore, invalid_use_of_internal_member, annotate_overrides, non_constant_identifier_names, curly_braces_in_flow_control_structures, prefer_const_literals_to_create_immutables, unused_field
|
|
|
|
import 'api.dart';
|
|
import 'dart:async';
|
|
import 'dart:convert';
|
|
import 'frb_generated.dart';
|
|
import 'frb_generated.io.dart'
|
|
if (dart.library.js_interop) 'frb_generated.web.dart';
|
|
import 'package:flutter_rust_bridge/flutter_rust_bridge_for_generated.dart';
|
|
|
|
/// Main entrypoint of the Rust API
|
|
class RustLib extends BaseEntrypoint<RustLibApi, RustLibApiImpl, RustLibWire> {
|
|
@internal
|
|
static final instance = RustLib._();
|
|
|
|
RustLib._();
|
|
|
|
/// Initialize flutter_rust_bridge
|
|
static Future<void> init({
|
|
RustLibApi? api,
|
|
BaseHandler? handler,
|
|
ExternalLibrary? externalLibrary,
|
|
bool forceSameCodegenVersion = true,
|
|
}) async {
|
|
await instance.initImpl(
|
|
api: api,
|
|
handler: handler,
|
|
externalLibrary: externalLibrary,
|
|
forceSameCodegenVersion: forceSameCodegenVersion,
|
|
);
|
|
}
|
|
|
|
/// Initialize flutter_rust_bridge in mock mode.
|
|
/// No libraries for FFI are loaded.
|
|
static void initMock({
|
|
required RustLibApi api,
|
|
}) {
|
|
instance.initMockImpl(
|
|
api: api,
|
|
);
|
|
}
|
|
|
|
/// Dispose flutter_rust_bridge
|
|
///
|
|
/// The call to this function is optional, since flutter_rust_bridge (and everything else)
|
|
/// is automatically disposed when the app stops.
|
|
static void dispose() => instance.disposeImpl();
|
|
|
|
@override
|
|
ApiImplConstructor<RustLibApiImpl, RustLibWire> get apiImplConstructor =>
|
|
RustLibApiImpl.new;
|
|
|
|
@override
|
|
WireConstructor<RustLibWire> get wireConstructor =>
|
|
RustLibWire.fromExternalLibrary;
|
|
|
|
@override
|
|
Future<void> executeRustInitializers() async {}
|
|
|
|
@override
|
|
ExternalLibraryLoaderConfig get defaultExternalLibraryLoaderConfig =>
|
|
kDefaultExternalLibraryLoaderConfig;
|
|
|
|
@override
|
|
String get codegenVersion => '2.13.0';
|
|
|
|
@override
|
|
int get rustContentHash => 389194750;
|
|
|
|
static const kDefaultExternalLibraryLoaderConfig =
|
|
ExternalLibraryLoaderConfig(
|
|
stem: 'netdesk_frb',
|
|
ioDirectory: '../frb/target/release/',
|
|
webPrefix: 'pkg/',
|
|
wasmBindgenName: 'wasm_bindgen',
|
|
);
|
|
}
|
|
|
|
abstract class RustLibApi extends BaseApi {
|
|
Future<BigInt> crateApiConnect(
|
|
{required String wsUrl,
|
|
required String hostId,
|
|
required String password,
|
|
required String totp});
|
|
|
|
void crateApiCtrlAltDel({required BigInt handle});
|
|
|
|
void crateApiDisconnect({required BigInt handle});
|
|
|
|
Stream<NdHostEvent> crateApiHostEvents({required BigInt handle});
|
|
|
|
String crateApiHostGenId();
|
|
|
|
String crateApiHostGenPassword();
|
|
|
|
void crateApiHostPushFrame(
|
|
{required BigInt handle,
|
|
required List<int> data,
|
|
required bool keyframe});
|
|
|
|
Future<BigInt> crateApiHostStart(
|
|
{required String wsUrl,
|
|
required String hostId,
|
|
required String name,
|
|
required String password,
|
|
required int width,
|
|
required int height});
|
|
|
|
void crateApiHostStop({required BigInt handle});
|
|
|
|
void crateApiMonitorSwitch({required BigInt handle, required int i});
|
|
|
|
void crateApiSendChat({required BigInt handle, required String text});
|
|
|
|
void crateApiSendKey(
|
|
{required BigInt handle, required String code, required bool down});
|
|
|
|
void crateApiSendMouse(
|
|
{required BigInt handle,
|
|
required int x,
|
|
required int y,
|
|
required int buttons,
|
|
required double wheel,
|
|
required double hwheel});
|
|
|
|
int crateApiSessionCurrentMonitor({required BigInt handle});
|
|
|
|
Stream<NdEvent> crateApiSessionEvents({required BigInt handle});
|
|
|
|
List<NdMonitor> crateApiSessionMonitors({required BigInt handle});
|
|
|
|
void crateApiSetClipboard({required BigInt handle, required String text});
|
|
|
|
void crateApiSetQuality(
|
|
{required BigInt handle,
|
|
required int fps,
|
|
required int bitrate,
|
|
required double scale});
|
|
}
|
|
|
|
class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi {
|
|
RustLibApiImpl({
|
|
required super.handler,
|
|
required super.wire,
|
|
required super.generalizedFrbRustBinding,
|
|
required super.portManager,
|
|
});
|
|
|
|
@override
|
|
Future<BigInt> crateApiConnect(
|
|
{required String wsUrl,
|
|
required String hostId,
|
|
required String password,
|
|
required String totp}) {
|
|
return handler.executeNormal(NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_String(wsUrl, serializer);
|
|
sse_encode_String(hostId, serializer);
|
|
sse_encode_String(password, serializer);
|
|
sse_encode_String(totp, serializer);
|
|
pdeCallFfi(generalizedFrbRustBinding, serializer,
|
|
funcId: 1, port: port_);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_u_64,
|
|
decodeErrorData: null,
|
|
),
|
|
constMeta: kCrateApiConnectConstMeta,
|
|
argValues: [wsUrl, hostId, password, totp],
|
|
apiImpl: this,
|
|
));
|
|
}
|
|
|
|
TaskConstMeta get kCrateApiConnectConstMeta => const TaskConstMeta(
|
|
debugName: "connect",
|
|
argNames: ["wsUrl", "hostId", "password", "totp"],
|
|
);
|
|
|
|
@override
|
|
void crateApiCtrlAltDel({required BigInt handle}) {
|
|
return handler.executeSync(SyncTask(
|
|
callFfi: () {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_u_64(handle, serializer);
|
|
return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 2)!;
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: null,
|
|
),
|
|
constMeta: kCrateApiCtrlAltDelConstMeta,
|
|
argValues: [handle],
|
|
apiImpl: this,
|
|
));
|
|
}
|
|
|
|
TaskConstMeta get kCrateApiCtrlAltDelConstMeta => const TaskConstMeta(
|
|
debugName: "ctrl_alt_del",
|
|
argNames: ["handle"],
|
|
);
|
|
|
|
@override
|
|
void crateApiDisconnect({required BigInt handle}) {
|
|
return handler.executeSync(SyncTask(
|
|
callFfi: () {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_u_64(handle, serializer);
|
|
return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 3)!;
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: null,
|
|
),
|
|
constMeta: kCrateApiDisconnectConstMeta,
|
|
argValues: [handle],
|
|
apiImpl: this,
|
|
));
|
|
}
|
|
|
|
TaskConstMeta get kCrateApiDisconnectConstMeta => const TaskConstMeta(
|
|
debugName: "disconnect",
|
|
argNames: ["handle"],
|
|
);
|
|
|
|
@override
|
|
Stream<NdHostEvent> crateApiHostEvents({required BigInt handle}) {
|
|
final sink = RustStreamSink<NdHostEvent>();
|
|
unawaited(handler.executeNormal(NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_u_64(handle, serializer);
|
|
sse_encode_StreamSink_nd_host_event_Sse(sink, serializer);
|
|
pdeCallFfi(generalizedFrbRustBinding, serializer,
|
|
funcId: 4, port: port_);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: null,
|
|
),
|
|
constMeta: kCrateApiHostEventsConstMeta,
|
|
argValues: [handle, sink],
|
|
apiImpl: this,
|
|
)));
|
|
return sink.stream;
|
|
}
|
|
|
|
TaskConstMeta get kCrateApiHostEventsConstMeta => const TaskConstMeta(
|
|
debugName: "host_events",
|
|
argNames: ["handle", "sink"],
|
|
);
|
|
|
|
@override
|
|
String crateApiHostGenId() {
|
|
return handler.executeSync(SyncTask(
|
|
callFfi: () {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 5)!;
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_String,
|
|
decodeErrorData: null,
|
|
),
|
|
constMeta: kCrateApiHostGenIdConstMeta,
|
|
argValues: [],
|
|
apiImpl: this,
|
|
));
|
|
}
|
|
|
|
TaskConstMeta get kCrateApiHostGenIdConstMeta => const TaskConstMeta(
|
|
debugName: "host_gen_id",
|
|
argNames: [],
|
|
);
|
|
|
|
@override
|
|
String crateApiHostGenPassword() {
|
|
return handler.executeSync(SyncTask(
|
|
callFfi: () {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 6)!;
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_String,
|
|
decodeErrorData: null,
|
|
),
|
|
constMeta: kCrateApiHostGenPasswordConstMeta,
|
|
argValues: [],
|
|
apiImpl: this,
|
|
));
|
|
}
|
|
|
|
TaskConstMeta get kCrateApiHostGenPasswordConstMeta => const TaskConstMeta(
|
|
debugName: "host_gen_password",
|
|
argNames: [],
|
|
);
|
|
|
|
@override
|
|
void crateApiHostPushFrame(
|
|
{required BigInt handle,
|
|
required List<int> data,
|
|
required bool keyframe}) {
|
|
return handler.executeSync(SyncTask(
|
|
callFfi: () {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_u_64(handle, serializer);
|
|
sse_encode_list_prim_u_8_loose(data, serializer);
|
|
sse_encode_bool(keyframe, serializer);
|
|
return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 7)!;
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: null,
|
|
),
|
|
constMeta: kCrateApiHostPushFrameConstMeta,
|
|
argValues: [handle, data, keyframe],
|
|
apiImpl: this,
|
|
));
|
|
}
|
|
|
|
TaskConstMeta get kCrateApiHostPushFrameConstMeta => const TaskConstMeta(
|
|
debugName: "host_push_frame",
|
|
argNames: ["handle", "data", "keyframe"],
|
|
);
|
|
|
|
@override
|
|
Future<BigInt> crateApiHostStart(
|
|
{required String wsUrl,
|
|
required String hostId,
|
|
required String name,
|
|
required String password,
|
|
required int width,
|
|
required int height}) {
|
|
return handler.executeNormal(NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_String(wsUrl, serializer);
|
|
sse_encode_String(hostId, serializer);
|
|
sse_encode_String(name, serializer);
|
|
sse_encode_String(password, serializer);
|
|
sse_encode_u_32(width, serializer);
|
|
sse_encode_u_32(height, serializer);
|
|
pdeCallFfi(generalizedFrbRustBinding, serializer,
|
|
funcId: 8, port: port_);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_u_64,
|
|
decodeErrorData: null,
|
|
),
|
|
constMeta: kCrateApiHostStartConstMeta,
|
|
argValues: [wsUrl, hostId, name, password, width, height],
|
|
apiImpl: this,
|
|
));
|
|
}
|
|
|
|
TaskConstMeta get kCrateApiHostStartConstMeta => const TaskConstMeta(
|
|
debugName: "host_start",
|
|
argNames: ["wsUrl", "hostId", "name", "password", "width", "height"],
|
|
);
|
|
|
|
@override
|
|
void crateApiHostStop({required BigInt handle}) {
|
|
return handler.executeSync(SyncTask(
|
|
callFfi: () {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_u_64(handle, serializer);
|
|
return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 9)!;
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: null,
|
|
),
|
|
constMeta: kCrateApiHostStopConstMeta,
|
|
argValues: [handle],
|
|
apiImpl: this,
|
|
));
|
|
}
|
|
|
|
TaskConstMeta get kCrateApiHostStopConstMeta => const TaskConstMeta(
|
|
debugName: "host_stop",
|
|
argNames: ["handle"],
|
|
);
|
|
|
|
@override
|
|
void crateApiMonitorSwitch({required BigInt handle, required int i}) {
|
|
return handler.executeSync(SyncTask(
|
|
callFfi: () {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_u_64(handle, serializer);
|
|
sse_encode_i_32(i, serializer);
|
|
return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 10)!;
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: null,
|
|
),
|
|
constMeta: kCrateApiMonitorSwitchConstMeta,
|
|
argValues: [handle, i],
|
|
apiImpl: this,
|
|
));
|
|
}
|
|
|
|
TaskConstMeta get kCrateApiMonitorSwitchConstMeta => const TaskConstMeta(
|
|
debugName: "monitor_switch",
|
|
argNames: ["handle", "i"],
|
|
);
|
|
|
|
@override
|
|
void crateApiSendChat({required BigInt handle, required String text}) {
|
|
return handler.executeSync(SyncTask(
|
|
callFfi: () {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_u_64(handle, serializer);
|
|
sse_encode_String(text, serializer);
|
|
return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 11)!;
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: null,
|
|
),
|
|
constMeta: kCrateApiSendChatConstMeta,
|
|
argValues: [handle, text],
|
|
apiImpl: this,
|
|
));
|
|
}
|
|
|
|
TaskConstMeta get kCrateApiSendChatConstMeta => const TaskConstMeta(
|
|
debugName: "send_chat",
|
|
argNames: ["handle", "text"],
|
|
);
|
|
|
|
@override
|
|
void crateApiSendKey(
|
|
{required BigInt handle, required String code, required bool down}) {
|
|
return handler.executeSync(SyncTask(
|
|
callFfi: () {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_u_64(handle, serializer);
|
|
sse_encode_String(code, serializer);
|
|
sse_encode_bool(down, serializer);
|
|
return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 12)!;
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: null,
|
|
),
|
|
constMeta: kCrateApiSendKeyConstMeta,
|
|
argValues: [handle, code, down],
|
|
apiImpl: this,
|
|
));
|
|
}
|
|
|
|
TaskConstMeta get kCrateApiSendKeyConstMeta => const TaskConstMeta(
|
|
debugName: "send_key",
|
|
argNames: ["handle", "code", "down"],
|
|
);
|
|
|
|
@override
|
|
void crateApiSendMouse(
|
|
{required BigInt handle,
|
|
required int x,
|
|
required int y,
|
|
required int buttons,
|
|
required double wheel,
|
|
required double hwheel}) {
|
|
return handler.executeSync(SyncTask(
|
|
callFfi: () {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_u_64(handle, serializer);
|
|
sse_encode_i_32(x, serializer);
|
|
sse_encode_i_32(y, serializer);
|
|
sse_encode_u_32(buttons, serializer);
|
|
sse_encode_f_32(wheel, serializer);
|
|
sse_encode_f_32(hwheel, serializer);
|
|
return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 13)!;
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: null,
|
|
),
|
|
constMeta: kCrateApiSendMouseConstMeta,
|
|
argValues: [handle, x, y, buttons, wheel, hwheel],
|
|
apiImpl: this,
|
|
));
|
|
}
|
|
|
|
TaskConstMeta get kCrateApiSendMouseConstMeta => const TaskConstMeta(
|
|
debugName: "send_mouse",
|
|
argNames: ["handle", "x", "y", "buttons", "wheel", "hwheel"],
|
|
);
|
|
|
|
@override
|
|
int crateApiSessionCurrentMonitor({required BigInt handle}) {
|
|
return handler.executeSync(SyncTask(
|
|
callFfi: () {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_u_64(handle, serializer);
|
|
return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 14)!;
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_i_32,
|
|
decodeErrorData: null,
|
|
),
|
|
constMeta: kCrateApiSessionCurrentMonitorConstMeta,
|
|
argValues: [handle],
|
|
apiImpl: this,
|
|
));
|
|
}
|
|
|
|
TaskConstMeta get kCrateApiSessionCurrentMonitorConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "session_current_monitor",
|
|
argNames: ["handle"],
|
|
);
|
|
|
|
@override
|
|
Stream<NdEvent> crateApiSessionEvents({required BigInt handle}) {
|
|
final sink = RustStreamSink<NdEvent>();
|
|
unawaited(handler.executeNormal(NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_u_64(handle, serializer);
|
|
sse_encode_StreamSink_nd_event_Sse(sink, serializer);
|
|
pdeCallFfi(generalizedFrbRustBinding, serializer,
|
|
funcId: 15, port: port_);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: null,
|
|
),
|
|
constMeta: kCrateApiSessionEventsConstMeta,
|
|
argValues: [handle, sink],
|
|
apiImpl: this,
|
|
)));
|
|
return sink.stream;
|
|
}
|
|
|
|
TaskConstMeta get kCrateApiSessionEventsConstMeta => const TaskConstMeta(
|
|
debugName: "session_events",
|
|
argNames: ["handle", "sink"],
|
|
);
|
|
|
|
@override
|
|
List<NdMonitor> crateApiSessionMonitors({required BigInt handle}) {
|
|
return handler.executeSync(SyncTask(
|
|
callFfi: () {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_u_64(handle, serializer);
|
|
return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 16)!;
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_list_nd_monitor,
|
|
decodeErrorData: null,
|
|
),
|
|
constMeta: kCrateApiSessionMonitorsConstMeta,
|
|
argValues: [handle],
|
|
apiImpl: this,
|
|
));
|
|
}
|
|
|
|
TaskConstMeta get kCrateApiSessionMonitorsConstMeta => const TaskConstMeta(
|
|
debugName: "session_monitors",
|
|
argNames: ["handle"],
|
|
);
|
|
|
|
@override
|
|
void crateApiSetClipboard({required BigInt handle, required String text}) {
|
|
return handler.executeSync(SyncTask(
|
|
callFfi: () {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_u_64(handle, serializer);
|
|
sse_encode_String(text, serializer);
|
|
return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 17)!;
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: null,
|
|
),
|
|
constMeta: kCrateApiSetClipboardConstMeta,
|
|
argValues: [handle, text],
|
|
apiImpl: this,
|
|
));
|
|
}
|
|
|
|
TaskConstMeta get kCrateApiSetClipboardConstMeta => const TaskConstMeta(
|
|
debugName: "set_clipboard",
|
|
argNames: ["handle", "text"],
|
|
);
|
|
|
|
@override
|
|
void crateApiSetQuality(
|
|
{required BigInt handle,
|
|
required int fps,
|
|
required int bitrate,
|
|
required double scale}) {
|
|
return handler.executeSync(SyncTask(
|
|
callFfi: () {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_u_64(handle, serializer);
|
|
sse_encode_u_32(fps, serializer);
|
|
sse_encode_u_32(bitrate, serializer);
|
|
sse_encode_f_32(scale, serializer);
|
|
return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 18)!;
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: null,
|
|
),
|
|
constMeta: kCrateApiSetQualityConstMeta,
|
|
argValues: [handle, fps, bitrate, scale],
|
|
apiImpl: this,
|
|
));
|
|
}
|
|
|
|
TaskConstMeta get kCrateApiSetQualityConstMeta => const TaskConstMeta(
|
|
debugName: "set_quality",
|
|
argNames: ["handle", "fps", "bitrate", "scale"],
|
|
);
|
|
|
|
@protected
|
|
AnyhowException dco_decode_AnyhowException(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return AnyhowException(raw as String);
|
|
}
|
|
|
|
@protected
|
|
RustStreamSink<NdEvent> dco_decode_StreamSink_nd_event_Sse(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
throw UnimplementedError();
|
|
}
|
|
|
|
@protected
|
|
RustStreamSink<NdHostEvent> dco_decode_StreamSink_nd_host_event_Sse(
|
|
dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
throw UnimplementedError();
|
|
}
|
|
|
|
@protected
|
|
String dco_decode_String(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return raw as String;
|
|
}
|
|
|
|
@protected
|
|
bool dco_decode_bool(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return raw as bool;
|
|
}
|
|
|
|
@protected
|
|
double dco_decode_f_32(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return raw as double;
|
|
}
|
|
|
|
@protected
|
|
int dco_decode_i_32(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return raw as int;
|
|
}
|
|
|
|
@protected
|
|
List<NdMonitor> dco_decode_list_nd_monitor(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return (raw as List<dynamic>).map(dco_decode_nd_monitor).toList();
|
|
}
|
|
|
|
@protected
|
|
List<int> dco_decode_list_prim_u_8_loose(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return raw as List<int>;
|
|
}
|
|
|
|
@protected
|
|
Uint8List dco_decode_list_prim_u_8_strict(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return raw as Uint8List;
|
|
}
|
|
|
|
@protected
|
|
NdEvent dco_decode_nd_event(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
switch (raw[0]) {
|
|
case 0:
|
|
return const NdEvent_Connecting();
|
|
case 1:
|
|
return NdEvent_Connected(
|
|
w: dco_decode_u_32(raw[1]),
|
|
h: dco_decode_u_32(raw[2]),
|
|
e2E: dco_decode_bool(raw[3]),
|
|
hostName: dco_decode_String(raw[4]),
|
|
);
|
|
case 2:
|
|
return NdEvent_Frame(
|
|
width: dco_decode_u_32(raw[1]),
|
|
height: dco_decode_u_32(raw[2]),
|
|
rgba: dco_decode_list_prim_u_8_strict(raw[3]),
|
|
);
|
|
case 3:
|
|
return NdEvent_Ended(
|
|
reason: dco_decode_String(raw[1]),
|
|
);
|
|
case 4:
|
|
return NdEvent_Denied(
|
|
reason: dco_decode_String(raw[1]),
|
|
);
|
|
case 5:
|
|
return NdEvent_ChatMessage(
|
|
from: dco_decode_String(raw[1]),
|
|
text: dco_decode_String(raw[2]),
|
|
);
|
|
case 6:
|
|
return NdEvent_Clipboard(
|
|
text: dco_decode_String(raw[1]),
|
|
);
|
|
default:
|
|
throw Exception("unreachable");
|
|
}
|
|
}
|
|
|
|
@protected
|
|
NdHostEvent dco_decode_nd_host_event(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
switch (raw[0]) {
|
|
case 0:
|
|
return const NdHostEvent_Registered();
|
|
case 1:
|
|
return NdHostEvent_ViewerConnected(
|
|
e2E: dco_decode_bool(raw[1]),
|
|
);
|
|
case 2:
|
|
return const NdHostEvent_ViewerLeft();
|
|
case 3:
|
|
return NdHostEvent_Mouse(
|
|
x: dco_decode_i_32(raw[1]),
|
|
y: dco_decode_i_32(raw[2]),
|
|
buttons: dco_decode_u_32(raw[3]),
|
|
wheel: dco_decode_f_32(raw[4]),
|
|
);
|
|
case 4:
|
|
return NdHostEvent_Key(
|
|
code: dco_decode_String(raw[1]),
|
|
down: dco_decode_bool(raw[2]),
|
|
);
|
|
case 5:
|
|
return const NdHostEvent_KeyframeRequested();
|
|
case 6:
|
|
return NdHostEvent_Quality(
|
|
fps: dco_decode_u_32(raw[1]),
|
|
bitrate: dco_decode_u_32(raw[2]),
|
|
scale: dco_decode_f_32(raw[3]),
|
|
);
|
|
case 7:
|
|
return const NdHostEvent_Reconnecting();
|
|
case 8:
|
|
return NdHostEvent_Ended(
|
|
reason: dco_decode_String(raw[1]),
|
|
);
|
|
default:
|
|
throw Exception("unreachable");
|
|
}
|
|
}
|
|
|
|
@protected
|
|
NdMonitor dco_decode_nd_monitor(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
final arr = raw as List<dynamic>;
|
|
if (arr.length != 3)
|
|
throw Exception('unexpected arr length: expect 3 but see ${arr.length}');
|
|
return NdMonitor(
|
|
i: dco_decode_i_32(arr[0]),
|
|
w: dco_decode_u_32(arr[1]),
|
|
h: dco_decode_u_32(arr[2]),
|
|
);
|
|
}
|
|
|
|
@protected
|
|
int dco_decode_u_32(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return raw as int;
|
|
}
|
|
|
|
@protected
|
|
BigInt dco_decode_u_64(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return dcoDecodeU64(raw);
|
|
}
|
|
|
|
@protected
|
|
int dco_decode_u_8(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return raw as int;
|
|
}
|
|
|
|
@protected
|
|
void dco_decode_unit(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return;
|
|
}
|
|
|
|
@protected
|
|
AnyhowException sse_decode_AnyhowException(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
var inner = sse_decode_String(deserializer);
|
|
return AnyhowException(inner);
|
|
}
|
|
|
|
@protected
|
|
RustStreamSink<NdEvent> sse_decode_StreamSink_nd_event_Sse(
|
|
SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
throw UnimplementedError('Unreachable ()');
|
|
}
|
|
|
|
@protected
|
|
RustStreamSink<NdHostEvent> sse_decode_StreamSink_nd_host_event_Sse(
|
|
SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
throw UnimplementedError('Unreachable ()');
|
|
}
|
|
|
|
@protected
|
|
String sse_decode_String(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
var inner = sse_decode_list_prim_u_8_strict(deserializer);
|
|
return utf8.decoder.convert(inner);
|
|
}
|
|
|
|
@protected
|
|
bool sse_decode_bool(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
return deserializer.buffer.getUint8() != 0;
|
|
}
|
|
|
|
@protected
|
|
double sse_decode_f_32(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
return deserializer.buffer.getFloat32();
|
|
}
|
|
|
|
@protected
|
|
int sse_decode_i_32(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
return deserializer.buffer.getInt32();
|
|
}
|
|
|
|
@protected
|
|
List<NdMonitor> sse_decode_list_nd_monitor(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
|
|
var len_ = sse_decode_i_32(deserializer);
|
|
var ans_ = <NdMonitor>[];
|
|
for (var idx_ = 0; idx_ < len_; ++idx_) {
|
|
ans_.add(sse_decode_nd_monitor(deserializer));
|
|
}
|
|
return ans_;
|
|
}
|
|
|
|
@protected
|
|
List<int> sse_decode_list_prim_u_8_loose(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
var len_ = sse_decode_i_32(deserializer);
|
|
return deserializer.buffer.getUint8List(len_);
|
|
}
|
|
|
|
@protected
|
|
Uint8List sse_decode_list_prim_u_8_strict(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
var len_ = sse_decode_i_32(deserializer);
|
|
return deserializer.buffer.getUint8List(len_);
|
|
}
|
|
|
|
@protected
|
|
NdEvent sse_decode_nd_event(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
|
|
var tag_ = sse_decode_i_32(deserializer);
|
|
switch (tag_) {
|
|
case 0:
|
|
return const NdEvent_Connecting();
|
|
case 1:
|
|
var var_w = sse_decode_u_32(deserializer);
|
|
var var_h = sse_decode_u_32(deserializer);
|
|
var var_e2E = sse_decode_bool(deserializer);
|
|
var var_hostName = sse_decode_String(deserializer);
|
|
return NdEvent_Connected(
|
|
w: var_w, h: var_h, e2E: var_e2E, hostName: var_hostName);
|
|
case 2:
|
|
var var_width = sse_decode_u_32(deserializer);
|
|
var var_height = sse_decode_u_32(deserializer);
|
|
var var_rgba = sse_decode_list_prim_u_8_strict(deserializer);
|
|
return NdEvent_Frame(
|
|
width: var_width, height: var_height, rgba: var_rgba);
|
|
case 3:
|
|
var var_reason = sse_decode_String(deserializer);
|
|
return NdEvent_Ended(reason: var_reason);
|
|
case 4:
|
|
var var_reason = sse_decode_String(deserializer);
|
|
return NdEvent_Denied(reason: var_reason);
|
|
case 5:
|
|
var var_from = sse_decode_String(deserializer);
|
|
var var_text = sse_decode_String(deserializer);
|
|
return NdEvent_ChatMessage(from: var_from, text: var_text);
|
|
case 6:
|
|
var var_text = sse_decode_String(deserializer);
|
|
return NdEvent_Clipboard(text: var_text);
|
|
default:
|
|
throw UnimplementedError('');
|
|
}
|
|
}
|
|
|
|
@protected
|
|
NdHostEvent sse_decode_nd_host_event(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
|
|
var tag_ = sse_decode_i_32(deserializer);
|
|
switch (tag_) {
|
|
case 0:
|
|
return const NdHostEvent_Registered();
|
|
case 1:
|
|
var var_e2E = sse_decode_bool(deserializer);
|
|
return NdHostEvent_ViewerConnected(e2E: var_e2E);
|
|
case 2:
|
|
return const NdHostEvent_ViewerLeft();
|
|
case 3:
|
|
var var_x = sse_decode_i_32(deserializer);
|
|
var var_y = sse_decode_i_32(deserializer);
|
|
var var_buttons = sse_decode_u_32(deserializer);
|
|
var var_wheel = sse_decode_f_32(deserializer);
|
|
return NdHostEvent_Mouse(
|
|
x: var_x, y: var_y, buttons: var_buttons, wheel: var_wheel);
|
|
case 4:
|
|
var var_code = sse_decode_String(deserializer);
|
|
var var_down = sse_decode_bool(deserializer);
|
|
return NdHostEvent_Key(code: var_code, down: var_down);
|
|
case 5:
|
|
return const NdHostEvent_KeyframeRequested();
|
|
case 6:
|
|
var var_fps = sse_decode_u_32(deserializer);
|
|
var var_bitrate = sse_decode_u_32(deserializer);
|
|
var var_scale = sse_decode_f_32(deserializer);
|
|
return NdHostEvent_Quality(
|
|
fps: var_fps, bitrate: var_bitrate, scale: var_scale);
|
|
case 7:
|
|
return const NdHostEvent_Reconnecting();
|
|
case 8:
|
|
var var_reason = sse_decode_String(deserializer);
|
|
return NdHostEvent_Ended(reason: var_reason);
|
|
default:
|
|
throw UnimplementedError('');
|
|
}
|
|
}
|
|
|
|
@protected
|
|
NdMonitor sse_decode_nd_monitor(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
var var_i = sse_decode_i_32(deserializer);
|
|
var var_w = sse_decode_u_32(deserializer);
|
|
var var_h = sse_decode_u_32(deserializer);
|
|
return NdMonitor(i: var_i, w: var_w, h: var_h);
|
|
}
|
|
|
|
@protected
|
|
int sse_decode_u_32(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
return deserializer.buffer.getUint32();
|
|
}
|
|
|
|
@protected
|
|
BigInt sse_decode_u_64(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
return deserializer.buffer.getBigUint64();
|
|
}
|
|
|
|
@protected
|
|
int sse_decode_u_8(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
return deserializer.buffer.getUint8();
|
|
}
|
|
|
|
@protected
|
|
void sse_decode_unit(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_AnyhowException(
|
|
AnyhowException self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_String(self.message, serializer);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_StreamSink_nd_event_Sse(
|
|
RustStreamSink<NdEvent> self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_String(
|
|
self.setupAndSerialize(
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_nd_event,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
)),
|
|
serializer);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_StreamSink_nd_host_event_Sse(
|
|
RustStreamSink<NdHostEvent> self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_String(
|
|
self.setupAndSerialize(
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_nd_host_event,
|
|
decodeErrorData: sse_decode_AnyhowException,
|
|
)),
|
|
serializer);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_String(String self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_list_prim_u_8_strict(utf8.encoder.convert(self), serializer);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_bool(bool self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
serializer.buffer.putUint8(self ? 1 : 0);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_f_32(double self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
serializer.buffer.putFloat32(self);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_i_32(int self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
serializer.buffer.putInt32(self);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_list_nd_monitor(
|
|
List<NdMonitor> self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_i_32(self.length, serializer);
|
|
for (final item in self) {
|
|
sse_encode_nd_monitor(item, serializer);
|
|
}
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_list_prim_u_8_loose(
|
|
List<int> self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_i_32(self.length, serializer);
|
|
serializer.buffer
|
|
.putUint8List(self is Uint8List ? self : Uint8List.fromList(self));
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_list_prim_u_8_strict(
|
|
Uint8List self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_i_32(self.length, serializer);
|
|
serializer.buffer.putUint8List(self);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_nd_event(NdEvent self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
switch (self) {
|
|
case NdEvent_Connecting():
|
|
sse_encode_i_32(0, serializer);
|
|
case NdEvent_Connected(
|
|
w: final w,
|
|
h: final h,
|
|
e2E: final e2E,
|
|
hostName: final hostName
|
|
):
|
|
sse_encode_i_32(1, serializer);
|
|
sse_encode_u_32(w, serializer);
|
|
sse_encode_u_32(h, serializer);
|
|
sse_encode_bool(e2E, serializer);
|
|
sse_encode_String(hostName, serializer);
|
|
case NdEvent_Frame(
|
|
width: final width,
|
|
height: final height,
|
|
rgba: final rgba
|
|
):
|
|
sse_encode_i_32(2, serializer);
|
|
sse_encode_u_32(width, serializer);
|
|
sse_encode_u_32(height, serializer);
|
|
sse_encode_list_prim_u_8_strict(rgba, serializer);
|
|
case NdEvent_Ended(reason: final reason):
|
|
sse_encode_i_32(3, serializer);
|
|
sse_encode_String(reason, serializer);
|
|
case NdEvent_Denied(reason: final reason):
|
|
sse_encode_i_32(4, serializer);
|
|
sse_encode_String(reason, serializer);
|
|
case NdEvent_ChatMessage(from: final from, text: final text):
|
|
sse_encode_i_32(5, serializer);
|
|
sse_encode_String(from, serializer);
|
|
sse_encode_String(text, serializer);
|
|
case NdEvent_Clipboard(text: final text):
|
|
sse_encode_i_32(6, serializer);
|
|
sse_encode_String(text, serializer);
|
|
}
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_nd_host_event(NdHostEvent self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
switch (self) {
|
|
case NdHostEvent_Registered():
|
|
sse_encode_i_32(0, serializer);
|
|
case NdHostEvent_ViewerConnected(e2E: final e2E):
|
|
sse_encode_i_32(1, serializer);
|
|
sse_encode_bool(e2E, serializer);
|
|
case NdHostEvent_ViewerLeft():
|
|
sse_encode_i_32(2, serializer);
|
|
case NdHostEvent_Mouse(
|
|
x: final x,
|
|
y: final y,
|
|
buttons: final buttons,
|
|
wheel: final wheel
|
|
):
|
|
sse_encode_i_32(3, serializer);
|
|
sse_encode_i_32(x, serializer);
|
|
sse_encode_i_32(y, serializer);
|
|
sse_encode_u_32(buttons, serializer);
|
|
sse_encode_f_32(wheel, serializer);
|
|
case NdHostEvent_Key(code: final code, down: final down):
|
|
sse_encode_i_32(4, serializer);
|
|
sse_encode_String(code, serializer);
|
|
sse_encode_bool(down, serializer);
|
|
case NdHostEvent_KeyframeRequested():
|
|
sse_encode_i_32(5, serializer);
|
|
case NdHostEvent_Quality(
|
|
fps: final fps,
|
|
bitrate: final bitrate,
|
|
scale: final scale
|
|
):
|
|
sse_encode_i_32(6, serializer);
|
|
sse_encode_u_32(fps, serializer);
|
|
sse_encode_u_32(bitrate, serializer);
|
|
sse_encode_f_32(scale, serializer);
|
|
case NdHostEvent_Reconnecting():
|
|
sse_encode_i_32(7, serializer);
|
|
case NdHostEvent_Ended(reason: final reason):
|
|
sse_encode_i_32(8, serializer);
|
|
sse_encode_String(reason, serializer);
|
|
}
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_nd_monitor(NdMonitor self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_i_32(self.i, serializer);
|
|
sse_encode_u_32(self.w, serializer);
|
|
sse_encode_u_32(self.h, serializer);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_u_32(int self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
serializer.buffer.putUint32(self);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_u_64(BigInt self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
serializer.buffer.putBigUint64(self);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_u_8(int self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
serializer.buffer.putUint8(self);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_unit(void self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
}
|
|
}
|