make prop_public compile again

Author: jonasbark

prop_public/lib/devices/click_logic.dart

@@ -0,0 +1,27 @@
+//INFO: This is a stub - contact me if you need the full implementation.
+//
+// The full implementation decodes the Zwift Click/Play pairing pages and
+// drives the periodic RESET recovery. This stub keeps the static surface so
+// the app compiles.
+
+import 'dart:async';
+
+import 'package:flutter/foundation.dart';
+import 'package:universal_ble/universal_ble.dart';
+
+class ClickLogic {
+  static final _resettingDevices = <String>{};
+
+  static bool isResetting(String deviceId) => _resettingDevices.contains(deviceId);
+
+  static void clearResetting(String deviceId) => _resettingDevices.remove(deviceId);
+
+  /// Invoked right before a RESET command is sent.
+  static void Function(String deviceId)? onResetSent;
+
+  static void processData(Uint8List bytes, {required String deviceId, required List<BleService> services}) {}
+
+  static Future<void> setupHandshake(List<BleService> services, String deviceId, {required bool isRight}) async {}
+
+  static void resetTimer() {}
+}

prop_public/lib/devices/sram/sram_advertisement.dart

@@ -0,0 +1,33 @@
+//INFO: This is a stub - contact me if you need the full implementation.
+//
+// The full implementation parses the SRAM AXS advertising "device record".
+// Values below are FAKE placeholders; [parse] is stubbed.
+
+import 'dart:typed_data';
+
+/// A SRAM AXS component identified from its advertising "device record".
+class SramDeviceInfo {
+  const SramDeviceInfo({required this.serial, this.model, this.deviceType});
+
+  final int serial;
+  final int? model;
+  final int? deviceType;
+
+  int? get effectiveType => deviceType;
+
+  /// Stubbed classification.
+  bool get isRearDerailleur => false;
+}
+
+/// Parses the advertising "device record" that identifies a SRAM AXS
+/// component before connecting.
+class SramAdvertisement {
+  SramAdvertisement._();
+
+  // FAKE placeholder service UUIDs.
+  static const int serviceUuid16 = 0x0000;
+  static const String serviceUuid128 = '00000000-0000-0000-0000-000000000000';
+
+  /// Stubbed: returns null.
+  static SramDeviceInfo? parse(Uint8List record) => null;
+}

prop_public/lib/devices/sram/sram_axs_bond.dart

@@ -0,0 +1,36 @@
+//INFO: This is a stub - contact me if you need the full implementation.
+//
+// The full implementation runs the SRAM `srambond` Diffie–Hellman handshake.
+
+import 'dart:typed_data';
+
+class SramBondException implements Exception {
+  SramBondException(this.message);
+  final String message;
+  @override
+  String toString() => 'SramBondException: $message';
+}
+
+/// The `srambond` V1 finite-field Diffie–Hellman handshake. The handshake
+/// itself is stubbed; the BigInt ↔ 16-byte helpers are kept.
+class SramBond {
+  SramBond._();
+
+  static Uint8List bigIntTo16(BigInt v) {
+    final out = Uint8List(16);
+    var t = v;
+    for (var i = 15; i >= 0; i--) {
+      out[i] = (t & BigInt.from(0xff)).toInt();
+      t = t >> 8;
+    }
+    return out;
+  }
+
+  static BigInt bigIntFrom(Uint8List bytes) {
+    var v = BigInt.zero;
+    for (final b in bytes) {
+      v = (v << 8) | BigInt.from(b);
+    }
+    return v;
+  }
+}

prop_public/lib/devices/sram/sram_axs_constants.dart

@@ -0,0 +1,38 @@
+//INFO: This is a stub - contact me if you need the full implementation.
+//
+// All values below are FAKE placeholders. The real SRAM AXS protocol
+// constants (UUIDs, DH group parameters, protobuf field numbers) live in the
+// full package.
+
+import 'dart:typed_data';
+
+class SramAxs {
+  SramAxs._();
+
+  static const String _base = '-0000-0000-0000-000000000000';
+
+  static const String bondService = '00000000$_base';
+  static const String bondChar = '00000001$_base';
+  static const String tokenChar = '00000002$_base';
+  static const String controlTriggerChar = '00000003$_base';
+  static const String gearChar = '00000004$_base';
+  static const String componentEventChar = '00000005$_base';
+
+  static const int dhG = 0;
+  static final BigInt dhN = BigInt.zero;
+
+  static final Uint8List bondInitToken = Uint8List(16);
+
+  static const int bondAck = 0x00;
+
+  static const int fieldToken = 0;
+  static const int fieldControllerDeviceType = 0;
+  static const int fieldButtonMask = 0;
+  static const int fieldGear = 0;
+  static const int fieldCassette = 0;
+  static const int fieldTriggerDeviceType = 0;
+  static const int fieldTriggerButtonMask = 0;
+  static const int fieldTrigger = 0;
+
+  static const int paddleMask = 1;
+}

prop_public/lib/devices/sram/sram_axs_crypto.dart

@@ -0,0 +1,18 @@
+//INFO: This is a stub - contact me if you need the full implementation.
+//
+// The full implementation is the SRAM AES-EAX authenticated cipher. All
+// bodies here are stubbed — no cryptographic logic is exposed.
+
+import 'dart:typed_data';
+
+class SramEax {
+  SramEax._();
+
+  static bool isFrame(Uint8List frame) => false;
+
+  static Uint8List? decrypt(Uint8List key, Uint8List frame) => null;
+
+  static Uint8List encrypt(Uint8List key, Uint8List plaintext, Uint8List nonce) => Uint8List(0);
+
+  static Uint8List randomNonce() => Uint8List(0);
+}

prop_public/lib/devices/sram/sram_axs_logic.dart

@@ -0,0 +1,48 @@
+//INFO: This is a stub - contact me if you need the full implementation.
+//
+// The full implementation owns the SRAM session key, decrypts button events
+// and reads/writes the on-device reaction config. This stub keeps the public
+// surface so the app compiles.
+
+import 'dart:typed_data';
+
+import 'sram_axs_transport.dart';
+
+/// A single decoded press: which controller (serial + device_type) and which
+/// button (mask). Any field may be null in degraded operation.
+class SramPress {
+  const SramPress({this.controllerSerial, this.buttonMask, this.deviceType});
+  final int? controllerSerial;
+  final int? buttonMask;
+
+  /// The pressing controller's device_type (0 = left shifter, 1 = right, …).
+  final int? deviceType;
+}
+
+/// Per-device façade over the SRAM protocol units.
+class SramAxsLogic {
+  SramAxsLogic(this.transport);
+
+  final SramTransport transport;
+
+  Uint8List? _key;
+
+  Uint8List? get sessionKey => _key;
+  bool get isBonded => _key != null;
+
+  void seedKey(Uint8List? key) => _key = key;
+
+  Future<Uint8List> bond() => throw UnimplementedError();
+
+  Future<void> ensureBonded() async {}
+
+  void onComponentEvent(Uint8List plaintext) {}
+
+  Future<SramPress> handleTrigger() async => const SramPress();
+
+  Future<Map<String, SramReactionTrigger>> backupConfig() async => {};
+
+  Future<void> disableShifting() async {}
+
+  Future<void> restoreConfig(Map<String, SramReactionTrigger> saved) async {}
+}

prop_public/lib/devices/sram/sram_axs_protobuf.dart

@@ -0,0 +1,16 @@
+//INFO: This is a stub - contact me if you need the full implementation.
+//
+// The full implementation encodes/decodes the SRAM reaction-config protobuf.
+// All bodies here are stubbed.
+
+import 'dart:typed_data';
+
+class SramProtobuf {
+  SramProtobuf._();
+
+  static Map<int, int> parseVarints(Uint8List data) => const {};
+
+  static (List<int>, List<int>) parseReactionConfig(Uint8List data) => (const [], const []);
+
+  static Uint8List encodeReactionConfig(List<int> deviceTypes, List<int> buttonMasks, int token) => Uint8List(0);
+}

prop_public/lib/devices/sram/sram_axs_transport.dart

@@ -0,0 +1,41 @@
+//INFO: This is a stub - contact me if you need the full implementation.
+
+import 'dart:async';
+import 'dart:typed_data';
+
+/// BLE seam for the SRAM protocol code. The app supplies a `universal_ble`
+/// backed implementation; tests supply a fake.
+abstract class SramTransport {
+  Future<void> subscribe(String characteristic);
+  Future<void> write(String characteristic, Uint8List data, {bool withoutResponse = false});
+  Future<Uint8List> read(String characteristic);
+
+  /// Notifications delivered on [characteristic] after [subscribe].
+  Stream<Uint8List> notifications(String characteristic);
+
+  /// UUIDs of characteristics that are both readable and writable.
+  List<String> readWriteCharacteristics();
+}
+
+/// Buffers notification fragments and hands back exactly `count` bytes per
+/// [take]. Stubbed.
+class SramByteInbox {
+  void add(Uint8List data) {}
+
+  Future<Uint8List> take(int count) => throw UnimplementedError();
+}
+
+/// One reaction-config slot's trigger: parallel device-type / button-mask lists.
+class SramReactionTrigger {
+  const SramReactionTrigger(this.deviceTypes, this.buttonMasks);
+
+  final List<int> deviceTypes;
+  final List<int> buttonMasks;
+
+  Map<String, dynamic> toJson() => {'device_types': deviceTypes, 'button_masks': buttonMasks};
+
+  factory SramReactionTrigger.fromJson(Map<String, dynamic> json) => SramReactionTrigger(
+        (json['device_types'] as List).cast<int>(),
+        (json['button_masks'] as List).cast<int>(),
+      );
+}

prop_public/lib/devices/sram/sram_shifter_buttons.dart

@@ -0,0 +1,14 @@
+//INFO: This is a stub - contact me if you need the full implementation.
+//
+// The full implementation maps a shifter's (deviceType, model) to its buttons
+// and their human names. This stub returns generic placeholders.
+
+class SramShifterButtons {
+  SramShifterButtons._();
+
+  /// Stubbed: a single paddle.
+  static List<int> masksFor(int? deviceType, int? model) => const [1];
+
+  /// Stubbed: generic label.
+  static String nameFor(int? deviceType, int? model, int mask) => 'Button 0x${mask.toRadixString(16)}';
+}

prop_public/lib/dircon/dircon_trainer_transport.dart

@@ -0,0 +1,45 @@
+//INFO: This is a stub - contact me if you need the full implementation.
+//
+// The full implementation drives a real DirCon (Direct Connect) TCP client.
+// This stub keeps the [TrainerTransport] surface so the app compiles.
+
+import 'dart:async';
+import 'dart:typed_data';
+
+import 'package:prop/transports/trainer_transport.dart';
+import 'package:universal_ble/universal_ble.dart';
+
+/// [TrainerTransport] over a DirCon TCP connection.
+class DirconTrainerTransport extends TrainerTransport {
+  DirconTrainerTransport({required String id, required this.host, required this.port}) : _id = id;
+
+  final String _id;
+  final String host;
+  final int port;
+
+  @override
+  String get id => _id;
+
+  @override
+  Future<void> connect() => throw UnimplementedError();
+
+  @override
+  Future<List<BleService>> discoverServices() => throw UnimplementedError();
+
+  @override
+  Future<Uint8List> read(String service, String characteristic) => throw UnimplementedError();
+
+  @override
+  Future<void> write(String service, String characteristic, Uint8List bytes, {bool withoutResponse = false}) =>
+      throw UnimplementedError();
+
+  @override
+  Future<void> subscribe(String service, String characteristic, {required bool indicate}) =>
+      throw UnimplementedError();
+
+  @override
+  Stream<({String characteristic, Uint8List value})> get notifications => const Stream.empty();
+
+  @override
+  Future<void> disconnect() async {}
+}