1646 lines
50 KiB
Dart
1646 lines
50 KiB
Dart
// This file is automatically generated, so please do not edit it.
|
|
// @generated by `flutter_rust_bridge`@ 2.11.1.
|
|
|
|
// 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/commands.dart';
|
|
import 'dart:async';
|
|
import 'dart:convert';
|
|
import 'discovery/model.dart';
|
|
import 'event.dart';
|
|
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';
|
|
import 'transfer/model.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.11.1';
|
|
|
|
@override
|
|
int get rustContentHash => -782745325;
|
|
|
|
static const kDefaultExternalLibraryLoaderConfig =
|
|
ExternalLibraryLoaderConfig(
|
|
stem: 'rust_lib_mesh_drop_flutter',
|
|
ioDirectory: 'rust/target/release/',
|
|
webPrefix: 'pkg/',
|
|
);
|
|
}
|
|
|
|
abstract class RustLibApi extends BaseApi {
|
|
Future<void> crateApiCommandsCancelTransfer({required String id});
|
|
|
|
Future<void> crateApiCommandsClearTransfers();
|
|
|
|
Stream<AppEvent> crateApiCommandsCreateEventStream();
|
|
|
|
Future<void> crateApiCommandsDeleteTransfer({required String id});
|
|
|
|
Future<bool> crateApiCommandsGetAutoAccept();
|
|
|
|
Future<bool> crateApiCommandsGetEnableTls();
|
|
|
|
Future<String> crateApiCommandsGetHostname();
|
|
|
|
Future<List<Peer>> crateApiCommandsGetPeers();
|
|
|
|
Future<bool> crateApiCommandsGetSaveHistory();
|
|
|
|
Future<String> crateApiCommandsGetSavePath();
|
|
|
|
Future<List<Transfer>> crateApiCommandsGetTransfers();
|
|
|
|
Future<bool> crateApiCommandsIsTrusted({required String peerId});
|
|
|
|
Future<void> crateApiCommandsResolvePendingRequest({
|
|
required String id,
|
|
required bool accept,
|
|
required String path,
|
|
});
|
|
|
|
Future<void> crateApiCommandsSendFile({
|
|
required Peer target,
|
|
required String targetIp,
|
|
required String filePath,
|
|
});
|
|
|
|
Future<void> crateApiCommandsSendFolder({
|
|
required Peer target,
|
|
required String targetIp,
|
|
required String folderPath,
|
|
});
|
|
|
|
Future<void> crateApiCommandsSendText({
|
|
required Peer target,
|
|
required String targetIp,
|
|
required String text,
|
|
});
|
|
|
|
Future<void> crateApiCommandsSetAutoAccept({required bool autoAccept});
|
|
|
|
Future<void> crateApiCommandsSetEnableTls({required bool enableTls});
|
|
|
|
Future<void> crateApiCommandsSetHostname({required String hostname});
|
|
|
|
Future<void> crateApiCommandsSetSaveHistory({required bool saveHistory});
|
|
|
|
Future<void> crateApiCommandsSetSavePath({required String savePath});
|
|
|
|
Future<void> crateApiCommandsTrustPeer({required String peerId});
|
|
|
|
Future<void> crateApiCommandsUntrustPeer({required String peerId});
|
|
}
|
|
|
|
class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi {
|
|
RustLibApiImpl({
|
|
required super.handler,
|
|
required super.wire,
|
|
required super.generalizedFrbRustBinding,
|
|
required super.portManager,
|
|
});
|
|
|
|
@override
|
|
Future<void> crateApiCommandsCancelTransfer({required String id}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_String(id, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 1,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: null,
|
|
),
|
|
constMeta: kCrateApiCommandsCancelTransferConstMeta,
|
|
argValues: [id],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateApiCommandsCancelTransferConstMeta =>
|
|
const TaskConstMeta(debugName: "cancel_transfer", argNames: ["id"]);
|
|
|
|
@override
|
|
Future<void> crateApiCommandsClearTransfers() {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 2,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: null,
|
|
),
|
|
constMeta: kCrateApiCommandsClearTransfersConstMeta,
|
|
argValues: [],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateApiCommandsClearTransfersConstMeta =>
|
|
const TaskConstMeta(debugName: "clear_transfers", argNames: []);
|
|
|
|
@override
|
|
Stream<AppEvent> crateApiCommandsCreateEventStream() {
|
|
final sink = RustStreamSink<AppEvent>();
|
|
unawaited(
|
|
handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_StreamSink_app_event_Sse(sink, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 3,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: null,
|
|
),
|
|
constMeta: kCrateApiCommandsCreateEventStreamConstMeta,
|
|
argValues: [sink],
|
|
apiImpl: this,
|
|
),
|
|
),
|
|
);
|
|
return sink.stream;
|
|
}
|
|
|
|
TaskConstMeta get kCrateApiCommandsCreateEventStreamConstMeta =>
|
|
const TaskConstMeta(debugName: "create_event_stream", argNames: ["sink"]);
|
|
|
|
@override
|
|
Future<void> crateApiCommandsDeleteTransfer({required String id}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_String(id, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 4,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: null,
|
|
),
|
|
constMeta: kCrateApiCommandsDeleteTransferConstMeta,
|
|
argValues: [id],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateApiCommandsDeleteTransferConstMeta =>
|
|
const TaskConstMeta(debugName: "delete_transfer", argNames: ["id"]);
|
|
|
|
@override
|
|
Future<bool> crateApiCommandsGetAutoAccept() {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 5,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_bool,
|
|
decodeErrorData: null,
|
|
),
|
|
constMeta: kCrateApiCommandsGetAutoAcceptConstMeta,
|
|
argValues: [],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateApiCommandsGetAutoAcceptConstMeta =>
|
|
const TaskConstMeta(debugName: "get_auto_accept", argNames: []);
|
|
|
|
@override
|
|
Future<bool> crateApiCommandsGetEnableTls() {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 6,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_bool,
|
|
decodeErrorData: null,
|
|
),
|
|
constMeta: kCrateApiCommandsGetEnableTlsConstMeta,
|
|
argValues: [],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateApiCommandsGetEnableTlsConstMeta =>
|
|
const TaskConstMeta(debugName: "get_enable_tls", argNames: []);
|
|
|
|
@override
|
|
Future<String> crateApiCommandsGetHostname() {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 7,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_String,
|
|
decodeErrorData: null,
|
|
),
|
|
constMeta: kCrateApiCommandsGetHostnameConstMeta,
|
|
argValues: [],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateApiCommandsGetHostnameConstMeta =>
|
|
const TaskConstMeta(debugName: "get_hostname", argNames: []);
|
|
|
|
@override
|
|
Future<List<Peer>> crateApiCommandsGetPeers() {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 8,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_list_peer,
|
|
decodeErrorData: sse_decode_String,
|
|
),
|
|
constMeta: kCrateApiCommandsGetPeersConstMeta,
|
|
argValues: [],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateApiCommandsGetPeersConstMeta =>
|
|
const TaskConstMeta(debugName: "get_peers", argNames: []);
|
|
|
|
@override
|
|
Future<bool> crateApiCommandsGetSaveHistory() {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 9,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_bool,
|
|
decodeErrorData: null,
|
|
),
|
|
constMeta: kCrateApiCommandsGetSaveHistoryConstMeta,
|
|
argValues: [],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateApiCommandsGetSaveHistoryConstMeta =>
|
|
const TaskConstMeta(debugName: "get_save_history", argNames: []);
|
|
|
|
@override
|
|
Future<String> crateApiCommandsGetSavePath() {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 10,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_String,
|
|
decodeErrorData: null,
|
|
),
|
|
constMeta: kCrateApiCommandsGetSavePathConstMeta,
|
|
argValues: [],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateApiCommandsGetSavePathConstMeta =>
|
|
const TaskConstMeta(debugName: "get_save_path", argNames: []);
|
|
|
|
@override
|
|
Future<List<Transfer>> crateApiCommandsGetTransfers() {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 11,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_list_transfer,
|
|
decodeErrorData: null,
|
|
),
|
|
constMeta: kCrateApiCommandsGetTransfersConstMeta,
|
|
argValues: [],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateApiCommandsGetTransfersConstMeta =>
|
|
const TaskConstMeta(debugName: "get_transfers", argNames: []);
|
|
|
|
@override
|
|
Future<bool> crateApiCommandsIsTrusted({required String peerId}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_String(peerId, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 12,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_bool,
|
|
decodeErrorData: null,
|
|
),
|
|
constMeta: kCrateApiCommandsIsTrustedConstMeta,
|
|
argValues: [peerId],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateApiCommandsIsTrustedConstMeta =>
|
|
const TaskConstMeta(debugName: "is_trusted", argNames: ["peerId"]);
|
|
|
|
@override
|
|
Future<void> crateApiCommandsResolvePendingRequest({
|
|
required String id,
|
|
required bool accept,
|
|
required String path,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_String(id, serializer);
|
|
sse_encode_bool(accept, serializer);
|
|
sse_encode_String(path, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 13,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: null,
|
|
),
|
|
constMeta: kCrateApiCommandsResolvePendingRequestConstMeta,
|
|
argValues: [id, accept, path],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateApiCommandsResolvePendingRequestConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "resolve_pending_request",
|
|
argNames: ["id", "accept", "path"],
|
|
);
|
|
|
|
@override
|
|
Future<void> crateApiCommandsSendFile({
|
|
required Peer target,
|
|
required String targetIp,
|
|
required String filePath,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_box_autoadd_peer(target, serializer);
|
|
sse_encode_String(targetIp, serializer);
|
|
sse_encode_String(filePath, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 14,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: sse_decode_String,
|
|
),
|
|
constMeta: kCrateApiCommandsSendFileConstMeta,
|
|
argValues: [target, targetIp, filePath],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateApiCommandsSendFileConstMeta => const TaskConstMeta(
|
|
debugName: "send_file",
|
|
argNames: ["target", "targetIp", "filePath"],
|
|
);
|
|
|
|
@override
|
|
Future<void> crateApiCommandsSendFolder({
|
|
required Peer target,
|
|
required String targetIp,
|
|
required String folderPath,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_box_autoadd_peer(target, serializer);
|
|
sse_encode_String(targetIp, serializer);
|
|
sse_encode_String(folderPath, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 15,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: sse_decode_String,
|
|
),
|
|
constMeta: kCrateApiCommandsSendFolderConstMeta,
|
|
argValues: [target, targetIp, folderPath],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateApiCommandsSendFolderConstMeta => const TaskConstMeta(
|
|
debugName: "send_folder",
|
|
argNames: ["target", "targetIp", "folderPath"],
|
|
);
|
|
|
|
@override
|
|
Future<void> crateApiCommandsSendText({
|
|
required Peer target,
|
|
required String targetIp,
|
|
required String text,
|
|
}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_box_autoadd_peer(target, serializer);
|
|
sse_encode_String(targetIp, serializer);
|
|
sse_encode_String(text, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 16,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: sse_decode_String,
|
|
),
|
|
constMeta: kCrateApiCommandsSendTextConstMeta,
|
|
argValues: [target, targetIp, text],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateApiCommandsSendTextConstMeta => const TaskConstMeta(
|
|
debugName: "send_text",
|
|
argNames: ["target", "targetIp", "text"],
|
|
);
|
|
|
|
@override
|
|
Future<void> crateApiCommandsSetAutoAccept({required bool autoAccept}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_bool(autoAccept, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 17,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: null,
|
|
),
|
|
constMeta: kCrateApiCommandsSetAutoAcceptConstMeta,
|
|
argValues: [autoAccept],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateApiCommandsSetAutoAcceptConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "set_auto_accept",
|
|
argNames: ["autoAccept"],
|
|
);
|
|
|
|
@override
|
|
Future<void> crateApiCommandsSetEnableTls({required bool enableTls}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_bool(enableTls, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 18,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: null,
|
|
),
|
|
constMeta: kCrateApiCommandsSetEnableTlsConstMeta,
|
|
argValues: [enableTls],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateApiCommandsSetEnableTlsConstMeta =>
|
|
const TaskConstMeta(debugName: "set_enable_tls", argNames: ["enableTls"]);
|
|
|
|
@override
|
|
Future<void> crateApiCommandsSetHostname({required String hostname}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_String(hostname, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 19,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: null,
|
|
),
|
|
constMeta: kCrateApiCommandsSetHostnameConstMeta,
|
|
argValues: [hostname],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateApiCommandsSetHostnameConstMeta =>
|
|
const TaskConstMeta(debugName: "set_hostname", argNames: ["hostname"]);
|
|
|
|
@override
|
|
Future<void> crateApiCommandsSetSaveHistory({required bool saveHistory}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_bool(saveHistory, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 20,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: null,
|
|
),
|
|
constMeta: kCrateApiCommandsSetSaveHistoryConstMeta,
|
|
argValues: [saveHistory],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateApiCommandsSetSaveHistoryConstMeta =>
|
|
const TaskConstMeta(
|
|
debugName: "set_save_history",
|
|
argNames: ["saveHistory"],
|
|
);
|
|
|
|
@override
|
|
Future<void> crateApiCommandsSetSavePath({required String savePath}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_String(savePath, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 21,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: null,
|
|
),
|
|
constMeta: kCrateApiCommandsSetSavePathConstMeta,
|
|
argValues: [savePath],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateApiCommandsSetSavePathConstMeta =>
|
|
const TaskConstMeta(debugName: "set_save_path", argNames: ["savePath"]);
|
|
|
|
@override
|
|
Future<void> crateApiCommandsTrustPeer({required String peerId}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_String(peerId, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 22,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: sse_decode_String,
|
|
),
|
|
constMeta: kCrateApiCommandsTrustPeerConstMeta,
|
|
argValues: [peerId],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateApiCommandsTrustPeerConstMeta =>
|
|
const TaskConstMeta(debugName: "trust_peer", argNames: ["peerId"]);
|
|
|
|
@override
|
|
Future<void> crateApiCommandsUntrustPeer({required String peerId}) {
|
|
return handler.executeNormal(
|
|
NormalTask(
|
|
callFfi: (port_) {
|
|
final serializer = SseSerializer(generalizedFrbRustBinding);
|
|
sse_encode_String(peerId, serializer);
|
|
pdeCallFfi(
|
|
generalizedFrbRustBinding,
|
|
serializer,
|
|
funcId: 23,
|
|
port: port_,
|
|
);
|
|
},
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_unit,
|
|
decodeErrorData: null,
|
|
),
|
|
constMeta: kCrateApiCommandsUntrustPeerConstMeta,
|
|
argValues: [peerId],
|
|
apiImpl: this,
|
|
),
|
|
);
|
|
}
|
|
|
|
TaskConstMeta get kCrateApiCommandsUntrustPeerConstMeta =>
|
|
const TaskConstMeta(debugName: "untrust_peer", argNames: ["peerId"]);
|
|
|
|
@protected
|
|
AnyhowException dco_decode_AnyhowException(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return AnyhowException(raw as String);
|
|
}
|
|
|
|
@protected
|
|
Map<String, RouteState> dco_decode_Map_String_route_state_None(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return Map.fromEntries(
|
|
dco_decode_list_record_string_route_state(
|
|
raw,
|
|
).map((e) => MapEntry(e.$1, e.$2)),
|
|
);
|
|
}
|
|
|
|
@protected
|
|
RustStreamSink<AppEvent> dco_decode_StreamSink_app_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
|
|
AppEvent dco_decode_app_event(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
switch (raw[0]) {
|
|
case 0:
|
|
return AppEvent_TransferStatusChanged(
|
|
transfer: dco_decode_box_autoadd_transfer(raw[1]),
|
|
);
|
|
case 1:
|
|
return AppEvent_TransferProgressChanged(
|
|
id: dco_decode_String(raw[1]),
|
|
progress: dco_decode_f_64(raw[2]),
|
|
total: dco_decode_f_64(raw[3]),
|
|
speed: dco_decode_f_64(raw[4]),
|
|
);
|
|
case 2:
|
|
return AppEvent_PeerConnectOrUpdated(
|
|
peer: dco_decode_box_autoadd_peer(raw[1]),
|
|
);
|
|
case 3:
|
|
return AppEvent_PeerDisconnected(id: dco_decode_String(raw[1]));
|
|
case 4:
|
|
return AppEvent_TransferAdded(
|
|
transfer: dco_decode_box_autoadd_transfer(raw[1]),
|
|
);
|
|
case 5:
|
|
return AppEvent_TransferRemoved(id: dco_decode_String(raw[1]));
|
|
case 6:
|
|
return AppEvent_TransferClear();
|
|
default:
|
|
throw Exception("unreachable");
|
|
}
|
|
}
|
|
|
|
@protected
|
|
bool dco_decode_bool(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return raw as bool;
|
|
}
|
|
|
|
@protected
|
|
Peer dco_decode_box_autoadd_peer(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return dco_decode_peer(raw);
|
|
}
|
|
|
|
@protected
|
|
Transfer dco_decode_box_autoadd_transfer(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return dco_decode_transfer(raw);
|
|
}
|
|
|
|
@protected
|
|
CanceledBy dco_decode_canceled_by(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return CanceledBy.values[raw as int];
|
|
}
|
|
|
|
@protected
|
|
ContentType dco_decode_content_type(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return ContentType.values[raw as int];
|
|
}
|
|
|
|
@protected
|
|
double dco_decode_f_64(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
|
|
PlatformInt64 dco_decode_i_64(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return dcoDecodeI64(raw);
|
|
}
|
|
|
|
@protected
|
|
List<Peer> dco_decode_list_peer(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return (raw as List<dynamic>).map(dco_decode_peer).toList();
|
|
}
|
|
|
|
@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
|
|
List<(String, RouteState)> dco_decode_list_record_string_route_state(
|
|
dynamic raw,
|
|
) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return (raw as List<dynamic>)
|
|
.map(dco_decode_record_string_route_state)
|
|
.toList();
|
|
}
|
|
|
|
@protected
|
|
List<Transfer> dco_decode_list_transfer(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return (raw as List<dynamic>).map(dco_decode_transfer).toList();
|
|
}
|
|
|
|
@protected
|
|
Peer dco_decode_peer(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
final arr = raw as List<dynamic>;
|
|
if (arr.length != 8)
|
|
throw Exception('unexpected arr length: expect 8 but see ${arr.length}');
|
|
return Peer(
|
|
id: dco_decode_String(arr[0]),
|
|
name: dco_decode_String(arr[1]),
|
|
routes: dco_decode_Map_String_route_state_None(arr[2]),
|
|
port: dco_decode_u_16(arr[3]),
|
|
os: dco_decode_String(arr[4]),
|
|
publicKey: dco_decode_String(arr[5]),
|
|
trustMismatch: dco_decode_bool(arr[6]),
|
|
enableTls: dco_decode_bool(arr[7]),
|
|
);
|
|
}
|
|
|
|
@protected
|
|
(String, RouteState) dco_decode_record_string_route_state(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
final arr = raw as List<dynamic>;
|
|
if (arr.length != 2) {
|
|
throw Exception('Expected 2 elements, got ${arr.length}');
|
|
}
|
|
return (dco_decode_String(arr[0]), dco_decode_route_state(arr[1]));
|
|
}
|
|
|
|
@protected
|
|
RouteState dco_decode_route_state(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
final arr = raw as List<dynamic>;
|
|
if (arr.length != 2)
|
|
throw Exception('unexpected arr length: expect 2 but see ${arr.length}');
|
|
return RouteState(
|
|
ip: dco_decode_String(arr[0]),
|
|
lastSeen: dco_decode_f_64(arr[1]),
|
|
);
|
|
}
|
|
|
|
@protected
|
|
Transfer dco_decode_transfer(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
final arr = raw as List<dynamic>;
|
|
if (arr.length != 16)
|
|
throw Exception('unexpected arr length: expect 16 but see ${arr.length}');
|
|
return Transfer(
|
|
id: dco_decode_String(arr[0]),
|
|
createTime: dco_decode_f_64(arr[1]),
|
|
sender: dco_decode_peer(arr[2]),
|
|
senderIp: dco_decode_String(arr[3]),
|
|
fileName: dco_decode_String(arr[4]),
|
|
fileSize: dco_decode_f_64(arr[5]),
|
|
savePath: dco_decode_String(arr[6]),
|
|
status: dco_decode_transfer_status(arr[7]),
|
|
type: dco_decode_transfer_type(arr[8]),
|
|
contentType: dco_decode_content_type(arr[9]),
|
|
text: dco_decode_String(arr[10]),
|
|
errorMsg: dco_decode_String(arr[11]),
|
|
token: dco_decode_String(arr[12]),
|
|
progress: dco_decode_f_64(arr[13]),
|
|
lastReadTime: dco_decode_i_64(arr[14]),
|
|
speed: dco_decode_f_64(arr[15]),
|
|
);
|
|
}
|
|
|
|
@protected
|
|
TransferStatus dco_decode_transfer_status(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
switch (raw[0]) {
|
|
case 0:
|
|
return TransferStatus_Pending();
|
|
case 1:
|
|
return TransferStatus_Accepted();
|
|
case 2:
|
|
return TransferStatus_Rejected();
|
|
case 3:
|
|
return TransferStatus_Completed();
|
|
case 4:
|
|
return TransferStatus_Error();
|
|
case 5:
|
|
return TransferStatus_Canceled(dco_decode_canceled_by(raw[1]));
|
|
case 6:
|
|
return TransferStatus_Active();
|
|
default:
|
|
throw Exception("unreachable");
|
|
}
|
|
}
|
|
|
|
@protected
|
|
TransferType dco_decode_transfer_type(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return TransferType.values[raw as int];
|
|
}
|
|
|
|
@protected
|
|
int dco_decode_u_16(dynamic raw) {
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
return raw as int;
|
|
}
|
|
|
|
@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
|
|
Map<String, RouteState> sse_decode_Map_String_route_state_None(
|
|
SseDeserializer deserializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
var inner = sse_decode_list_record_string_route_state(deserializer);
|
|
return Map.fromEntries(inner.map((e) => MapEntry(e.$1, e.$2)));
|
|
}
|
|
|
|
@protected
|
|
RustStreamSink<AppEvent> sse_decode_StreamSink_app_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
|
|
AppEvent sse_decode_app_event(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
|
|
var tag_ = sse_decode_i_32(deserializer);
|
|
switch (tag_) {
|
|
case 0:
|
|
var var_transfer = sse_decode_box_autoadd_transfer(deserializer);
|
|
return AppEvent_TransferStatusChanged(transfer: var_transfer);
|
|
case 1:
|
|
var var_id = sse_decode_String(deserializer);
|
|
var var_progress = sse_decode_f_64(deserializer);
|
|
var var_total = sse_decode_f_64(deserializer);
|
|
var var_speed = sse_decode_f_64(deserializer);
|
|
return AppEvent_TransferProgressChanged(
|
|
id: var_id,
|
|
progress: var_progress,
|
|
total: var_total,
|
|
speed: var_speed,
|
|
);
|
|
case 2:
|
|
var var_peer = sse_decode_box_autoadd_peer(deserializer);
|
|
return AppEvent_PeerConnectOrUpdated(peer: var_peer);
|
|
case 3:
|
|
var var_id = sse_decode_String(deserializer);
|
|
return AppEvent_PeerDisconnected(id: var_id);
|
|
case 4:
|
|
var var_transfer = sse_decode_box_autoadd_transfer(deserializer);
|
|
return AppEvent_TransferAdded(transfer: var_transfer);
|
|
case 5:
|
|
var var_id = sse_decode_String(deserializer);
|
|
return AppEvent_TransferRemoved(id: var_id);
|
|
case 6:
|
|
return AppEvent_TransferClear();
|
|
default:
|
|
throw UnimplementedError('');
|
|
}
|
|
}
|
|
|
|
@protected
|
|
bool sse_decode_bool(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
return deserializer.buffer.getUint8() != 0;
|
|
}
|
|
|
|
@protected
|
|
Peer sse_decode_box_autoadd_peer(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
return (sse_decode_peer(deserializer));
|
|
}
|
|
|
|
@protected
|
|
Transfer sse_decode_box_autoadd_transfer(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
return (sse_decode_transfer(deserializer));
|
|
}
|
|
|
|
@protected
|
|
CanceledBy sse_decode_canceled_by(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
var inner = sse_decode_i_32(deserializer);
|
|
return CanceledBy.values[inner];
|
|
}
|
|
|
|
@protected
|
|
ContentType sse_decode_content_type(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
var inner = sse_decode_i_32(deserializer);
|
|
return ContentType.values[inner];
|
|
}
|
|
|
|
@protected
|
|
double sse_decode_f_64(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
return deserializer.buffer.getFloat64();
|
|
}
|
|
|
|
@protected
|
|
int sse_decode_i_32(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
return deserializer.buffer.getInt32();
|
|
}
|
|
|
|
@protected
|
|
PlatformInt64 sse_decode_i_64(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
return deserializer.buffer.getPlatformInt64();
|
|
}
|
|
|
|
@protected
|
|
List<Peer> sse_decode_list_peer(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
|
|
var len_ = sse_decode_i_32(deserializer);
|
|
var ans_ = <Peer>[];
|
|
for (var idx_ = 0; idx_ < len_; ++idx_) {
|
|
ans_.add(sse_decode_peer(deserializer));
|
|
}
|
|
return ans_;
|
|
}
|
|
|
|
@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
|
|
List<(String, RouteState)> sse_decode_list_record_string_route_state(
|
|
SseDeserializer deserializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
|
|
var len_ = sse_decode_i_32(deserializer);
|
|
var ans_ = <(String, RouteState)>[];
|
|
for (var idx_ = 0; idx_ < len_; ++idx_) {
|
|
ans_.add(sse_decode_record_string_route_state(deserializer));
|
|
}
|
|
return ans_;
|
|
}
|
|
|
|
@protected
|
|
List<Transfer> sse_decode_list_transfer(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
|
|
var len_ = sse_decode_i_32(deserializer);
|
|
var ans_ = <Transfer>[];
|
|
for (var idx_ = 0; idx_ < len_; ++idx_) {
|
|
ans_.add(sse_decode_transfer(deserializer));
|
|
}
|
|
return ans_;
|
|
}
|
|
|
|
@protected
|
|
Peer sse_decode_peer(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
var var_id = sse_decode_String(deserializer);
|
|
var var_name = sse_decode_String(deserializer);
|
|
var var_routes = sse_decode_Map_String_route_state_None(deserializer);
|
|
var var_port = sse_decode_u_16(deserializer);
|
|
var var_os = sse_decode_String(deserializer);
|
|
var var_publicKey = sse_decode_String(deserializer);
|
|
var var_trustMismatch = sse_decode_bool(deserializer);
|
|
var var_enableTls = sse_decode_bool(deserializer);
|
|
return Peer(
|
|
id: var_id,
|
|
name: var_name,
|
|
routes: var_routes,
|
|
port: var_port,
|
|
os: var_os,
|
|
publicKey: var_publicKey,
|
|
trustMismatch: var_trustMismatch,
|
|
enableTls: var_enableTls,
|
|
);
|
|
}
|
|
|
|
@protected
|
|
(String, RouteState) sse_decode_record_string_route_state(
|
|
SseDeserializer deserializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
var var_field0 = sse_decode_String(deserializer);
|
|
var var_field1 = sse_decode_route_state(deserializer);
|
|
return (var_field0, var_field1);
|
|
}
|
|
|
|
@protected
|
|
RouteState sse_decode_route_state(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
var var_ip = sse_decode_String(deserializer);
|
|
var var_lastSeen = sse_decode_f_64(deserializer);
|
|
return RouteState(ip: var_ip, lastSeen: var_lastSeen);
|
|
}
|
|
|
|
@protected
|
|
Transfer sse_decode_transfer(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
var var_id = sse_decode_String(deserializer);
|
|
var var_createTime = sse_decode_f_64(deserializer);
|
|
var var_sender = sse_decode_peer(deserializer);
|
|
var var_senderIp = sse_decode_String(deserializer);
|
|
var var_fileName = sse_decode_String(deserializer);
|
|
var var_fileSize = sse_decode_f_64(deserializer);
|
|
var var_savePath = sse_decode_String(deserializer);
|
|
var var_status = sse_decode_transfer_status(deserializer);
|
|
var var_type = sse_decode_transfer_type(deserializer);
|
|
var var_contentType = sse_decode_content_type(deserializer);
|
|
var var_text = sse_decode_String(deserializer);
|
|
var var_errorMsg = sse_decode_String(deserializer);
|
|
var var_token = sse_decode_String(deserializer);
|
|
var var_progress = sse_decode_f_64(deserializer);
|
|
var var_lastReadTime = sse_decode_i_64(deserializer);
|
|
var var_speed = sse_decode_f_64(deserializer);
|
|
return Transfer(
|
|
id: var_id,
|
|
createTime: var_createTime,
|
|
sender: var_sender,
|
|
senderIp: var_senderIp,
|
|
fileName: var_fileName,
|
|
fileSize: var_fileSize,
|
|
savePath: var_savePath,
|
|
status: var_status,
|
|
type: var_type,
|
|
contentType: var_contentType,
|
|
text: var_text,
|
|
errorMsg: var_errorMsg,
|
|
token: var_token,
|
|
progress: var_progress,
|
|
lastReadTime: var_lastReadTime,
|
|
speed: var_speed,
|
|
);
|
|
}
|
|
|
|
@protected
|
|
TransferStatus sse_decode_transfer_status(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
|
|
var tag_ = sse_decode_i_32(deserializer);
|
|
switch (tag_) {
|
|
case 0:
|
|
return TransferStatus_Pending();
|
|
case 1:
|
|
return TransferStatus_Accepted();
|
|
case 2:
|
|
return TransferStatus_Rejected();
|
|
case 3:
|
|
return TransferStatus_Completed();
|
|
case 4:
|
|
return TransferStatus_Error();
|
|
case 5:
|
|
var var_field0 = sse_decode_canceled_by(deserializer);
|
|
return TransferStatus_Canceled(var_field0);
|
|
case 6:
|
|
return TransferStatus_Active();
|
|
default:
|
|
throw UnimplementedError('');
|
|
}
|
|
}
|
|
|
|
@protected
|
|
TransferType sse_decode_transfer_type(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
var inner = sse_decode_i_32(deserializer);
|
|
return TransferType.values[inner];
|
|
}
|
|
|
|
@protected
|
|
int sse_decode_u_16(SseDeserializer deserializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
return deserializer.buffer.getUint16();
|
|
}
|
|
|
|
@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_Map_String_route_state_None(
|
|
Map<String, RouteState> self,
|
|
SseSerializer serializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_list_record_string_route_state(
|
|
self.entries.map((e) => (e.key, e.value)).toList(),
|
|
serializer,
|
|
);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_StreamSink_app_event_Sse(
|
|
RustStreamSink<AppEvent> self,
|
|
SseSerializer serializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_String(
|
|
self.setupAndSerialize(
|
|
codec: SseCodec(
|
|
decodeSuccessData: sse_decode_app_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_app_event(AppEvent self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
switch (self) {
|
|
case AppEvent_TransferStatusChanged(transfer: final transfer):
|
|
sse_encode_i_32(0, serializer);
|
|
sse_encode_box_autoadd_transfer(transfer, serializer);
|
|
case AppEvent_TransferProgressChanged(
|
|
id: final id,
|
|
progress: final progress,
|
|
total: final total,
|
|
speed: final speed,
|
|
):
|
|
sse_encode_i_32(1, serializer);
|
|
sse_encode_String(id, serializer);
|
|
sse_encode_f_64(progress, serializer);
|
|
sse_encode_f_64(total, serializer);
|
|
sse_encode_f_64(speed, serializer);
|
|
case AppEvent_PeerConnectOrUpdated(peer: final peer):
|
|
sse_encode_i_32(2, serializer);
|
|
sse_encode_box_autoadd_peer(peer, serializer);
|
|
case AppEvent_PeerDisconnected(id: final id):
|
|
sse_encode_i_32(3, serializer);
|
|
sse_encode_String(id, serializer);
|
|
case AppEvent_TransferAdded(transfer: final transfer):
|
|
sse_encode_i_32(4, serializer);
|
|
sse_encode_box_autoadd_transfer(transfer, serializer);
|
|
case AppEvent_TransferRemoved(id: final id):
|
|
sse_encode_i_32(5, serializer);
|
|
sse_encode_String(id, serializer);
|
|
case AppEvent_TransferClear():
|
|
sse_encode_i_32(6, 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_box_autoadd_peer(Peer self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_peer(self, serializer);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_box_autoadd_transfer(
|
|
Transfer self,
|
|
SseSerializer serializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_transfer(self, serializer);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_canceled_by(CanceledBy self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_i_32(self.index, serializer);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_content_type(ContentType self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_i_32(self.index, serializer);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_f_64(double self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
serializer.buffer.putFloat64(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_i_64(PlatformInt64 self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
serializer.buffer.putPlatformInt64(self);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_list_peer(List<Peer> 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_peer(item, serializer);
|
|
}
|
|
}
|
|
|
|
@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_list_record_string_route_state(
|
|
List<(String, RouteState)> 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_record_string_route_state(item, serializer);
|
|
}
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_list_transfer(List<Transfer> 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_transfer(item, serializer);
|
|
}
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_peer(Peer self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_String(self.id, serializer);
|
|
sse_encode_String(self.name, serializer);
|
|
sse_encode_Map_String_route_state_None(self.routes, serializer);
|
|
sse_encode_u_16(self.port, serializer);
|
|
sse_encode_String(self.os, serializer);
|
|
sse_encode_String(self.publicKey, serializer);
|
|
sse_encode_bool(self.trustMismatch, serializer);
|
|
sse_encode_bool(self.enableTls, serializer);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_record_string_route_state(
|
|
(String, RouteState) self,
|
|
SseSerializer serializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_String(self.$1, serializer);
|
|
sse_encode_route_state(self.$2, serializer);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_route_state(RouteState self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_String(self.ip, serializer);
|
|
sse_encode_f_64(self.lastSeen, serializer);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_transfer(Transfer self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_String(self.id, serializer);
|
|
sse_encode_f_64(self.createTime, serializer);
|
|
sse_encode_peer(self.sender, serializer);
|
|
sse_encode_String(self.senderIp, serializer);
|
|
sse_encode_String(self.fileName, serializer);
|
|
sse_encode_f_64(self.fileSize, serializer);
|
|
sse_encode_String(self.savePath, serializer);
|
|
sse_encode_transfer_status(self.status, serializer);
|
|
sse_encode_transfer_type(self.type, serializer);
|
|
sse_encode_content_type(self.contentType, serializer);
|
|
sse_encode_String(self.text, serializer);
|
|
sse_encode_String(self.errorMsg, serializer);
|
|
sse_encode_String(self.token, serializer);
|
|
sse_encode_f_64(self.progress, serializer);
|
|
sse_encode_i_64(self.lastReadTime, serializer);
|
|
sse_encode_f_64(self.speed, serializer);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_transfer_status(
|
|
TransferStatus self,
|
|
SseSerializer serializer,
|
|
) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
switch (self) {
|
|
case TransferStatus_Pending():
|
|
sse_encode_i_32(0, serializer);
|
|
case TransferStatus_Accepted():
|
|
sse_encode_i_32(1, serializer);
|
|
case TransferStatus_Rejected():
|
|
sse_encode_i_32(2, serializer);
|
|
case TransferStatus_Completed():
|
|
sse_encode_i_32(3, serializer);
|
|
case TransferStatus_Error():
|
|
sse_encode_i_32(4, serializer);
|
|
case TransferStatus_Canceled(field0: final field0):
|
|
sse_encode_i_32(5, serializer);
|
|
sse_encode_canceled_by(field0, serializer);
|
|
case TransferStatus_Active():
|
|
sse_encode_i_32(6, serializer);
|
|
}
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_transfer_type(TransferType self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
sse_encode_i_32(self.index, serializer);
|
|
}
|
|
|
|
@protected
|
|
void sse_encode_u_16(int self, SseSerializer serializer) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
serializer.buffer.putUint16(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
|
|
}
|
|
}
|