2352 lines
83 KiB
Dart
2352 lines
83 KiB
Dart
// Chanora Flutter application — External Beta build.
|
|
//
|
|
// Builds on Internal Beta v0.3.0-beta.1:
|
|
// * server password field
|
|
// * bookmark list with add / connect / delete actions
|
|
// * channel tap-to-join with optional channel password
|
|
// * self input + output mute toggles + master output gain slider
|
|
// * diagnostics dialog + reconnect banner + identity persistence
|
|
// (all carried over from v0.3.0-beta.1)
|
|
|
|
import 'dart:async';
|
|
|
|
import 'package:connectivity_plus/connectivity_plus.dart';
|
|
import 'dart:io' show Platform, Process;
|
|
|
|
import 'package:flutter/foundation.dart';
|
|
import 'package:flutter/material.dart';
|
|
import 'package:flutter/services.dart';
|
|
import 'package:package_info_plus/package_info_plus.dart';
|
|
import 'package:path_provider/path_provider.dart';
|
|
|
|
import 'l10n/generated/app_localizations.dart';
|
|
import 'services/android_permissions_service.dart';
|
|
import 'src/rust/api.dart' as rust;
|
|
import 'src/rust/lib.dart' as rust_err;
|
|
import 'src/rust/frb_generated.dart';
|
|
import 'widgets/permission_state_banner.dart';
|
|
import 'widgets/voice_bar.dart';
|
|
import 'widgets/voice_compact.dart';
|
|
import 'widgets/voice_settings.dart';
|
|
|
|
bool get _isMacOS => !kIsWeb && Platform.isMacOS;
|
|
|
|
const Color _appSurfaceColor = Color(0xFFFFFBFE);
|
|
|
|
/// Top padding for macOS to clear traffic-light buttons.
|
|
const double _macOSTrafficLightPad = 56.0;
|
|
|
|
/// Translate a [LogicalKeyboardKey] into the platform-neutral label
|
|
/// stored by the PTT binding flow.
|
|
String? _pttDisplayLabelForKey(LogicalKeyboardKey k) {
|
|
if (k == LogicalKeyboardKey.space) return 'Space';
|
|
if (k == LogicalKeyboardKey.enter || k == LogicalKeyboardKey.numpadEnter) {
|
|
return 'Enter';
|
|
}
|
|
if (k == LogicalKeyboardKey.tab) return 'Tab';
|
|
if (k == LogicalKeyboardKey.escape) return 'Escape';
|
|
if (k == LogicalKeyboardKey.backspace) return 'Backspace';
|
|
if (k == LogicalKeyboardKey.delete) return 'Delete';
|
|
if (k == LogicalKeyboardKey.insert) return 'Insert';
|
|
if (k == LogicalKeyboardKey.home) return 'Home';
|
|
if (k == LogicalKeyboardKey.end) return 'End';
|
|
if (k == LogicalKeyboardKey.pageUp) return 'Page Up';
|
|
if (k == LogicalKeyboardKey.pageDown) return 'Page Down';
|
|
if (k == LogicalKeyboardKey.arrowUp) return 'Arrow Up';
|
|
if (k == LogicalKeyboardKey.arrowDown) return 'Arrow Down';
|
|
if (k == LogicalKeyboardKey.arrowLeft) return 'Arrow Left';
|
|
if (k == LogicalKeyboardKey.arrowRight) return 'Arrow Right';
|
|
if (k == LogicalKeyboardKey.shift ||
|
|
k == LogicalKeyboardKey.shiftLeft ||
|
|
k == LogicalKeyboardKey.shiftRight ||
|
|
k == LogicalKeyboardKey.control ||
|
|
k == LogicalKeyboardKey.controlLeft ||
|
|
k == LogicalKeyboardKey.controlRight ||
|
|
k == LogicalKeyboardKey.alt ||
|
|
k == LogicalKeyboardKey.altLeft ||
|
|
k == LogicalKeyboardKey.altRight ||
|
|
k == LogicalKeyboardKey.meta ||
|
|
k == LogicalKeyboardKey.metaLeft ||
|
|
k == LogicalKeyboardKey.metaRight ||
|
|
k == LogicalKeyboardKey.capsLock ||
|
|
k == LogicalKeyboardKey.numLock ||
|
|
k == LogicalKeyboardKey.scrollLock) {
|
|
return null;
|
|
}
|
|
final fallback = k.keyLabel.trim();
|
|
if (fallback.isEmpty) return null;
|
|
return fallback;
|
|
}
|
|
|
|
/// True when the host is a touch-only mobile platform without a
|
|
/// hardware keyboard. Mirrors the helpers in widgets/voice_bar.dart
|
|
/// and widgets/voice_settings.dart so the AppBar + narrow-mode
|
|
/// layout in main.dart can branch consistently.
|
|
bool get _isTouchOnlyPttHost {
|
|
if (kIsWeb) return false;
|
|
return Platform.isIOS || Platform.isAndroid;
|
|
}
|
|
|
|
/// Public version string shown in the About dialog. Resolved at
|
|
/// app init by combining a hardcoded semver baseline (kept in sync
|
|
/// with the git tag and pubspec.yaml's `version:` field) with the
|
|
/// platform-canonical build counter from `package_info_plus`.
|
|
///
|
|
/// Why hardcode the semver instead of reading the whole string
|
|
/// from `package_info_plus`: iOS rejects non-numeric characters
|
|
/// in `CFBundleShortVersionString` and Flutter therefore strips
|
|
/// `-rc.8` to `.8` when populating the Info.plist field. The
|
|
/// resulting `1.0.0.8` is technically valid on the App Store but
|
|
/// useless to humans tracking pre-release builds.
|
|
/// `package_info_plus.version` reflects that mangled value. The
|
|
/// build counter (`CFBundleVersion` / Android `versionCode`) does
|
|
/// pass through unmodified, so we use platform info for the
|
|
/// `+<build>` suffix only and pair it with the human-readable
|
|
/// semver baseline that this codebase already maintains as the
|
|
/// canonical release identity.
|
|
///
|
|
/// Bump `_kSemverBaseline` whenever the semver portion of
|
|
/// pubspec.yaml advances (e.g. rc.8 -> rc.9 -> 1.0.0). The
|
|
/// build-counter suffix changes automatically on every pubspec
|
|
/// `+<n>` bump because Flutter writes it into Info.plist.
|
|
const String _kSemverBaseline = 'v1.0.0-rc.8';
|
|
String _kAppVersion = _kSemverBaseline;
|
|
|
|
Future<void> main() async {
|
|
WidgetsFlutterBinding.ensureInitialized();
|
|
await RustLib.init();
|
|
await _resolveAppVersion();
|
|
unawaited(_wireStorage());
|
|
unawaited(_wireConnectivity());
|
|
_wireIosAudioLifecycle();
|
|
runApp(const ChanoraApp());
|
|
}
|
|
|
|
/// Wire the iOS AVAudioSession lifecycle MethodChannel.
|
|
///
|
|
/// Swift side (AppDelegate) posts route-change and interruption
|
|
/// events through `FlutterMethodChannel` named
|
|
/// `"chanora/ios_audio_lifecycle"`. This handler dispatches them to
|
|
/// the FRB bridge functions on the Rust side.
|
|
void _wireIosAudioLifecycle() {
|
|
const channel = MethodChannel('chanora/ios_audio_lifecycle');
|
|
channel.setMethodCallHandler((call) async {
|
|
try {
|
|
switch (call.method) {
|
|
case 'handleRouteChange':
|
|
rust.handleRouteChange();
|
|
break;
|
|
case 'handleInterruptionBegan':
|
|
rust.handleInterruptionBegan();
|
|
break;
|
|
case 'handleInterruptionEnded':
|
|
// `shouldResume` is passed from Swift as a bool argument.
|
|
final shouldResume = call.arguments as bool? ?? false;
|
|
rust.handleInterruptionEnded(shouldResume: shouldResume);
|
|
break;
|
|
default:
|
|
// Unknown method — ignore gracefully rather than crashing.
|
|
break;
|
|
}
|
|
} catch (_) {
|
|
// Errors from the Rust side are already logged there;
|
|
// don't propagate exceptions to the iOS framework.
|
|
}
|
|
});
|
|
}
|
|
|
|
/// Populate `_kAppVersion` by suffixing the platform-canonical
|
|
/// build number to `_kSemverBaseline`. Format:
|
|
/// `v1.0.0-rc.8+<build>` (e.g. `v1.0.0-rc.8+64`). The build
|
|
/// number is iOS `CFBundleVersion` / Android `versionCode`,
|
|
/// kept in sync with pubspec.yaml's `version: <semver>+<build>`.
|
|
Future<void> _resolveAppVersion() async {
|
|
try {
|
|
final info = await PackageInfo.fromPlatform();
|
|
// info.buildNumber = "64" (CFBundleVersion on iOS; survives
|
|
// the iOS version-string sanitiser that mangles
|
|
// CFBundleShortVersionString).
|
|
final build = info.buildNumber.isEmpty ? '' : '+${info.buildNumber}';
|
|
_kAppVersion = '$_kSemverBaseline$build';
|
|
} catch (_) {
|
|
// Keep the hardcoded baseline. The build counter is lost
|
|
// but the semver stays correct.
|
|
}
|
|
}
|
|
|
|
Future<void> _wireStorage() async {
|
|
try {
|
|
final dir = await getApplicationSupportDirectory();
|
|
await rust.initStorage(dir: dir.path);
|
|
} catch (_) {
|
|
// Best-effort; missing storage just means no identity persistence
|
|
// and no bookmark list this session.
|
|
}
|
|
}
|
|
|
|
rust.BridgeNetworkState _mapConnectivity(List<ConnectivityResult> results) {
|
|
if (results.isEmpty) return rust.BridgeNetworkState.unknown;
|
|
final allNone = results.every((r) => r == ConnectivityResult.none);
|
|
if (allNone) return rust.BridgeNetworkState.offline;
|
|
return rust.BridgeNetworkState.online;
|
|
}
|
|
|
|
Future<void> _wireConnectivity() async {
|
|
final connectivity = Connectivity();
|
|
try {
|
|
final initial = await connectivity.checkConnectivity();
|
|
rust.setNetworkState(state: _mapConnectivity(initial));
|
|
} catch (_) {}
|
|
connectivity.onConnectivityChanged.listen((results) {
|
|
rust.setNetworkState(state: _mapConnectivity(results));
|
|
});
|
|
}
|
|
|
|
class ChanoraApp extends StatelessWidget {
|
|
const ChanoraApp({super.key});
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
return AnnotatedRegion<SystemUiOverlayStyle>(
|
|
value: const SystemUiOverlayStyle(
|
|
statusBarColor: Colors.transparent,
|
|
statusBarIconBrightness: Brightness.dark,
|
|
systemNavigationBarColor: _appSurfaceColor,
|
|
systemNavigationBarDividerColor: _appSurfaceColor,
|
|
systemNavigationBarIconBrightness: Brightness.dark,
|
|
),
|
|
child: MaterialApp(
|
|
onGenerateTitle: (ctx) => AppL10n.of(ctx).appTitle,
|
|
// No "DEBUG" banner in the top-right corner. This is purely
|
|
// cosmetic for the developer-build experience; release builds
|
|
// never render it regardless of this flag.
|
|
debugShowCheckedModeBanner: false,
|
|
theme: ThemeData(
|
|
useMaterial3: true,
|
|
colorSchemeSeed: const Color(0xFF3F51B5),
|
|
scaffoldBackgroundColor: _appSurfaceColor,
|
|
),
|
|
localizationsDelegates: AppL10n.localizationsDelegates,
|
|
supportedLocales: AppL10n.supportedLocales,
|
|
home: const _BetaHome(),
|
|
),
|
|
);
|
|
}
|
|
}
|
|
|
|
enum _Phase { idle, connecting, connected }
|
|
|
|
class _BetaHome extends StatefulWidget {
|
|
const _BetaHome();
|
|
|
|
@override
|
|
State<_BetaHome> createState() => _BetaHomeState();
|
|
}
|
|
|
|
class _BetaHomeState extends State<_BetaHome> {
|
|
final _hostCtl = TextEditingController(text: 'cn.teamspeak.app');
|
|
final _nickCtl = TextEditingController(text: 'ChanoraBeta');
|
|
final _passwordCtl = TextEditingController();
|
|
|
|
_Phase _phase = _Phase.idle;
|
|
rust.BridgeSnapshot? _snapshot;
|
|
String? _error;
|
|
// ignore: unused_field
|
|
bool _audioStarted = false;
|
|
rust.BridgeAudioStats? _audioStats;
|
|
Timer? _statsTimer;
|
|
StreamSubscription<rust.BridgeEvent>? _eventsSub;
|
|
|
|
// v1 voice subsystem state (SDD-094/095/096/097). Driven by
|
|
// BridgeEvent::VoiceState.
|
|
bool _inChannel = false;
|
|
rust.BridgeTransmitMode _transmitMode = rust.BridgeTransmitMode.ptt;
|
|
bool _hardMute = false;
|
|
bool _hardMuteByPermission = false;
|
|
bool _permissionHardMuteClearInFlight = false;
|
|
int _releaseTailMs = 200;
|
|
BigInt? _currentVoiceChannelId;
|
|
BigInt? _pendingVoiceChannelId;
|
|
bool _canJoinVoiceChannel = true;
|
|
bool _canLeaveVoiceChannel = false;
|
|
|
|
String? _lostReason;
|
|
int? _reconnectAttempt;
|
|
int? _reconnectDelay;
|
|
|
|
bool _inputMuted = false;
|
|
bool _outputMuted = false;
|
|
// ignore: unused_field
|
|
double _outputGain = 1.0;
|
|
|
|
// Desktop PTT capability badge state (gen2 v0.9.3 / SDD-091).
|
|
// Populated by `BridgeEvent.PttCapability`. Defaults match the
|
|
// universal `FocusedPttBackend::focused()` descriptor so the UI
|
|
// shows an honest baseline even before the first event arrives.
|
|
String _pttLevel = 'L0Focused';
|
|
String _pttBackendId = 'focused';
|
|
String _pttBoundInputClass = 'keyboard';
|
|
// iOS interruption state from BridgeEvent::InterruptionState
|
|
// (SDD-101). Can be used by UI surfaces (banner/snackbar).
|
|
// ignore: unused_field
|
|
bool _iosAudioInterrupted = false;
|
|
// ignore: unused_field
|
|
bool _iosInterruptionShouldResume = false;
|
|
// Last platform-neutral key label the user saved in the
|
|
// `_PttBindingCaptureDialog` (e.g. "Space", "F10",
|
|
// "mouse-side-button:8"). Surfaced next to the capability
|
|
// badge so the user can remember which key drives PTT. The
|
|
// bridge-side `PttController` (SDD-088) holds the authoritative
|
|
// binding; this is a display-only cache that resets on app
|
|
// restart. Per DEC-027 the raw OS key code never lives here —
|
|
// only the platform-neutral label that already crossed into
|
|
// the Rust side.
|
|
String _pttBoundKeyLabel = '';
|
|
final Set<LogicalKeyboardKey> _focusedPttHeldKeys = <LogicalKeyboardKey>{};
|
|
|
|
List<rust.BridgeBookmark> _bookmarks = const [];
|
|
|
|
// SDD-106 / SRS-209: Android RECORD_AUDIO runtime permission service.
|
|
// Constructed at startup so cold-launch state is captured before the
|
|
// first voice_join attempt. On non-Android hosts the service
|
|
// short-circuits to "granted" and never wires the MethodChannel
|
|
// (see AndroidPermissionsService for the platform branch).
|
|
final AndroidPermissionsService _androidPermissions =
|
|
AndroidPermissionsService();
|
|
|
|
@override
|
|
void initState() {
|
|
super.initState();
|
|
HardwareKeyboard.instance.addHandler(_handleFocusedPttKey);
|
|
_eventsSub = rust.eventsStream().listen(_onEvent);
|
|
// SDD-106 §5: subscribe to Kotlin -> Dart permissionStateChanged
|
|
// events as early as possible so the listen-only banner reflects
|
|
// the system state on first frame.
|
|
_androidPermissions.start();
|
|
_androidPermissions.recordAudioState.addListener(
|
|
_onRecordAudioPermissionChanged,
|
|
);
|
|
unawaited(_reloadBookmarks());
|
|
unawaited(_hydratePttBinding());
|
|
}
|
|
|
|
void _onRecordAudioPermissionChanged() {
|
|
if (_androidPermissions.recordAudioState.value ==
|
|
AndroidRecordAudioPermissionState.granted) {
|
|
unawaited(_clearPermissionHardMute());
|
|
}
|
|
}
|
|
|
|
Future<void> _clearPermissionHardMute() async {
|
|
if (!_hardMuteByPermission || _permissionHardMuteClearInFlight) return;
|
|
_permissionHardMuteClearInFlight = true;
|
|
try {
|
|
await rust.setHardMute(muted: false);
|
|
if (!mounted || !_hardMuteByPermission) return;
|
|
setState(() {
|
|
_hardMute = false;
|
|
_hardMuteByPermission = false;
|
|
});
|
|
} catch (e) {
|
|
if (!mounted) return;
|
|
setState(() => _error = e.toString());
|
|
} finally {
|
|
_permissionHardMuteClearInFlight = false;
|
|
}
|
|
}
|
|
|
|
bool _handleFocusedPttKey(KeyEvent event) {
|
|
final label = _pttDisplayLabelForKey(event.logicalKey);
|
|
final isBoundKey =
|
|
_pttBoundKeyLabel.isNotEmpty && label == _pttBoundKeyLabel;
|
|
if (event is KeyUpEvent && _focusedPttHeldKeys.contains(event.logicalKey)) {
|
|
if (_focusedPttHeldKeys.remove(event.logicalKey)) {
|
|
unawaited(_setPtt(false));
|
|
}
|
|
return true;
|
|
}
|
|
if (_pttBackendId != 'focused' ||
|
|
_phase != _Phase.connected ||
|
|
!_inChannel ||
|
|
_transmitMode != rust.BridgeTransmitMode.ptt ||
|
|
!isBoundKey) {
|
|
return false;
|
|
}
|
|
if (event is KeyDownEvent) {
|
|
if (_focusedPttHeldKeys.add(event.logicalKey)) {
|
|
unawaited(_setPtt(true));
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void _releaseFocusedPttIfHeld() {
|
|
if (_focusedPttHeldKeys.isEmpty) return;
|
|
_focusedPttHeldKeys.clear();
|
|
unawaited(_setPtt(false, reportError: false));
|
|
}
|
|
|
|
/// Hydrate the bound-key display state from the bridge so the
|
|
/// Voice Bar shows the user's persisted hotkey label immediately
|
|
/// at launch — without having to wait for them to open the
|
|
/// binding dialog. The bridge returns empty strings when no
|
|
/// binding has ever been saved.
|
|
Future<void> _hydratePttBinding() async {
|
|
try {
|
|
final (inputClass, keyLabel) = await rust.getPttBinding();
|
|
if (!mounted) return;
|
|
if (keyLabel.isNotEmpty || inputClass.isNotEmpty) {
|
|
setState(() {
|
|
_pttBoundKeyLabel = keyLabel;
|
|
_pttBoundInputClass = inputClass;
|
|
});
|
|
}
|
|
} catch (_) {
|
|
// No persisted binding or storage not yet wired; not an error.
|
|
}
|
|
}
|
|
|
|
Future<void> _reloadBookmarks() async {
|
|
try {
|
|
final list = await rust.listBookmarks();
|
|
if (!mounted) return;
|
|
setState(() => _bookmarks = list);
|
|
} catch (_) {
|
|
// Bookmark store missing on this platform — empty list is fine.
|
|
}
|
|
}
|
|
|
|
void _onEvent(rust.BridgeEvent evt) {
|
|
if (!mounted) return;
|
|
switch (evt) {
|
|
case rust.BridgeEvent_Connected():
|
|
setState(() {
|
|
_phase = _Phase.connected;
|
|
_lostReason = null;
|
|
_reconnectAttempt = null;
|
|
_reconnectDelay = null;
|
|
});
|
|
case rust.BridgeEvent_Lost(:final reason):
|
|
setState(() {
|
|
_lostReason = reason;
|
|
_reconnectAttempt = null;
|
|
_reconnectDelay = null;
|
|
});
|
|
case rust.BridgeEvent_Reconnecting(:final attempt, :final delaySecs):
|
|
setState(() {
|
|
_reconnectAttempt = attempt;
|
|
_reconnectDelay = delaySecs;
|
|
});
|
|
case rust.BridgeEvent_Disconnected():
|
|
setState(() {
|
|
_phase = _Phase.idle;
|
|
_lostReason = null;
|
|
_reconnectAttempt = null;
|
|
_reconnectDelay = null;
|
|
});
|
|
case rust.BridgeEvent_AudioStarted():
|
|
setState(() => _audioStarted = true);
|
|
case rust.BridgeEvent_AudioStopped():
|
|
setState(() => _audioStarted = false);
|
|
case rust.BridgeEvent_SnapshotChanged():
|
|
unawaited(_onRefresh());
|
|
case rust.BridgeEvent_PttCapability(
|
|
:final level,
|
|
:final backendId,
|
|
:final boundInputClass,
|
|
):
|
|
setState(() {
|
|
_pttLevel = level;
|
|
_pttBackendId = backendId;
|
|
_pttBoundInputClass = boundInputClass;
|
|
});
|
|
if (backendId != 'focused') {
|
|
_releaseFocusedPttIfHeld();
|
|
}
|
|
case rust.BridgeEvent_VoiceState(
|
|
:final inChannel,
|
|
:final transmitMode,
|
|
:final mute,
|
|
:final releaseTailMs,
|
|
:final currentChannelId,
|
|
:final pendingTargetChannelId,
|
|
:final canJoin,
|
|
:final canLeave,
|
|
):
|
|
setState(() {
|
|
_inChannel = inChannel;
|
|
_transmitMode = transmitMode;
|
|
_hardMute = mute;
|
|
if (!mute) _hardMuteByPermission = false;
|
|
_releaseTailMs = releaseTailMs;
|
|
_audioStarted = inChannel;
|
|
_currentVoiceChannelId = currentChannelId;
|
|
_pendingVoiceChannelId = pendingTargetChannelId;
|
|
_canJoinVoiceChannel = canJoin;
|
|
_canLeaveVoiceChannel = canLeave;
|
|
});
|
|
if (inChannel) {
|
|
_ensureStatsTimer();
|
|
unawaited(_onRefresh());
|
|
} else {
|
|
_statsTimer?.cancel();
|
|
_statsTimer = null;
|
|
_releaseFocusedPttIfHeld();
|
|
}
|
|
if (transmitMode != rust.BridgeTransmitMode.ptt) {
|
|
_releaseFocusedPttIfHeld();
|
|
}
|
|
case rust.BridgeEvent_InterruptionState(
|
|
:final began,
|
|
:final shouldResume,
|
|
):
|
|
setState(() {
|
|
_iosAudioInterrupted = began;
|
|
_iosInterruptionShouldResume = shouldResume;
|
|
});
|
|
// Surface iOS audio interruption to the user (SDD-101).
|
|
// Use unawaited to stay inside the sync _onEvent stream
|
|
// without blocking it.
|
|
if (!mounted) return;
|
|
unawaited(() async {
|
|
if (!mounted) return;
|
|
final messenger = ScaffoldMessenger.of(context);
|
|
if (began) {
|
|
messenger.showSnackBar(
|
|
const SnackBar(
|
|
content: Text('Audio interrupted by system (phone call)'),
|
|
duration: Duration(seconds: 3),
|
|
backgroundColor: Colors.orange,
|
|
),
|
|
);
|
|
} else if (shouldResume) {
|
|
messenger.showSnackBar(
|
|
const SnackBar(
|
|
content: Text('Audio resuming'),
|
|
duration: Duration(seconds: 2),
|
|
backgroundColor: Colors.green,
|
|
),
|
|
);
|
|
}
|
|
}());
|
|
// SDD-106 §5/§6 / SRS-209: defensive observer of the
|
|
// authoritative Rust-side permission stream. The transmit
|
|
// clamp is already applied inside `chanora_bridge` before
|
|
// this event is broadcast. When permission later becomes
|
|
// granted, release only the permission-owned hard-mute; do
|
|
// not touch server-side input mute, which may be user-owned.
|
|
case rust.BridgeEvent_PermissionState(:final permission, :final state):
|
|
debugPrint(
|
|
'bridge permission_state: permission=$permission state=$state',
|
|
);
|
|
if (permission == 'android.permission.RECORD_AUDIO' &&
|
|
state == rust.PermissionStateKind.granted) {
|
|
unawaited(_clearPermissionHardMute());
|
|
}
|
|
}
|
|
}
|
|
|
|
void _ensureStatsTimer() {
|
|
if (_statsTimer != null) return;
|
|
// Poll at 80 ms (~12 Hz) — this is the loop that drives the
|
|
// Voice Bar's "PTT=on/off" indicator and the level meter, so
|
|
// it needs to be fast enough that users don't perceive a lag
|
|
// between physically pressing the bound key and seeing the
|
|
// UI change. 80 ms is well below the ~150 ms perceptual
|
|
// delay threshold and adds only a dozen tiny FFI calls per
|
|
// second to the load. A future push-based BridgeEvent for
|
|
// transmit-active transitions would let us drop this poll
|
|
// entirely.
|
|
_statsTimer = Timer.periodic(const Duration(milliseconds: 80), (_) async {
|
|
try {
|
|
final s = await rust.audioStats();
|
|
if (!mounted) return;
|
|
setState(() => _audioStats = s);
|
|
} catch (_) {}
|
|
});
|
|
}
|
|
|
|
@override
|
|
void dispose() {
|
|
HardwareKeyboard.instance.removeHandler(_handleFocusedPttKey);
|
|
_eventsSub?.cancel();
|
|
_statsTimer?.cancel();
|
|
_hostCtl.dispose();
|
|
_nickCtl.dispose();
|
|
_passwordCtl.dispose();
|
|
_androidPermissions.recordAudioState.removeListener(
|
|
_onRecordAudioPermissionChanged,
|
|
);
|
|
// SDD-106: detach the Kotlin -> Dart MethodChannel handler so a
|
|
// late invokeMethod from the platform side cannot land on this
|
|
// disposed state.
|
|
_androidPermissions.stop();
|
|
super.dispose();
|
|
}
|
|
|
|
Future<void> _onConnect({
|
|
String? host,
|
|
String? nickname,
|
|
String? password,
|
|
}) async {
|
|
setState(() {
|
|
_phase = _Phase.connecting;
|
|
_error = null;
|
|
_snapshot = null;
|
|
});
|
|
_releaseFocusedPttIfHeld();
|
|
try {
|
|
final snap = await rust.connect(
|
|
host: (host ?? _hostCtl.text).trim(),
|
|
nickname: (nickname ?? _nickCtl.text).trim(),
|
|
password: password ?? _passwordCtl.text,
|
|
);
|
|
if (!mounted) return;
|
|
setState(() {
|
|
_phase = _Phase.connected;
|
|
_applySnapshot(snap);
|
|
});
|
|
} catch (e) {
|
|
if (!mounted) return;
|
|
final errorStr = e.toString();
|
|
if (errorStr.contains('PermissionDenied') ||
|
|
errorStr.contains('Operation not permitted')) {
|
|
_showPermissionDeniedDialog(errorStr);
|
|
}
|
|
setState(() {
|
|
_phase = _Phase.idle;
|
|
_error = errorStr;
|
|
});
|
|
}
|
|
}
|
|
|
|
void _showPermissionDeniedDialog(String rawError) {
|
|
final l10n = AppL10n.of(context);
|
|
final isNetwork = rawError.contains('9987') || rawError.contains('connect');
|
|
showDialog(
|
|
context: context,
|
|
builder: (ctx) => AlertDialog(
|
|
title: Text(
|
|
isNetwork ? l10n.networkPermissionTitle : l10n.permissionDenied,
|
|
),
|
|
content: Text(
|
|
isNetwork
|
|
? l10n.networkPermissionBody
|
|
: l10n.microphonePermissionBody,
|
|
),
|
|
actions: [
|
|
if (Platform.isMacOS)
|
|
TextButton(
|
|
onPressed: () {
|
|
Navigator.pop(ctx);
|
|
try {
|
|
Process.run('open', [
|
|
'x-apple.systempreferences:com.apple.preference.security?Privacy_LocalNetwork',
|
|
]);
|
|
} catch (_) {}
|
|
},
|
|
child: Text(l10n.networkPermissionOpenSettings),
|
|
),
|
|
TextButton(
|
|
onPressed: () => Navigator.pop(ctx),
|
|
child: Text(MaterialLocalizations.of(context).okButtonLabel),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
}
|
|
|
|
// ignore: unused_element
|
|
Future<void> _setPtt(bool active, {bool reportError = true}) async {
|
|
try {
|
|
await rust.setPtt(active: active);
|
|
} catch (e) {
|
|
if (!mounted || !reportError) return;
|
|
setState(() => _error = e.toString());
|
|
}
|
|
}
|
|
|
|
// ignore: unused_element
|
|
Future<void> _toggleInputMute() async {
|
|
final next = !_inputMuted;
|
|
try {
|
|
await rust.setInputMuted(muted: next);
|
|
if (!mounted) return;
|
|
setState(() => _inputMuted = next);
|
|
} catch (e) {
|
|
if (!mounted) return;
|
|
setState(() => _error = e.toString());
|
|
}
|
|
}
|
|
|
|
Future<void> _toggleOutputMute() async {
|
|
final next = !_outputMuted;
|
|
try {
|
|
await rust.setOutputMuted(muted: next);
|
|
if (!mounted) return;
|
|
setState(() => _outputMuted = next);
|
|
} catch (e) {
|
|
if (!mounted) return;
|
|
setState(() => _error = e.toString());
|
|
}
|
|
}
|
|
|
|
// ignore: unused_element
|
|
Future<void> _setOutputGain(double value) async {
|
|
setState(() => _outputGain = value);
|
|
try {
|
|
await rust.setOutputGain(gain: value);
|
|
} catch (_) {
|
|
// Audio may not be started yet — that's fine; the next start_audio
|
|
// picks up the current slider position next time we plumb it.
|
|
}
|
|
}
|
|
|
|
Future<void> _onJoinChannel(
|
|
rust.BridgeChannel ch, {
|
|
bool askForPassword = false,
|
|
}) async {
|
|
if (!_canJoinVoiceChannel) return;
|
|
if (_pendingVoiceChannelId != null) return;
|
|
if (ch.id == _currentVoiceChannelId) return;
|
|
final l10n = AppL10n.of(context);
|
|
final messenger = ScaffoldMessenger.of(context);
|
|
String? password;
|
|
if (askForPassword) {
|
|
password = await _askChannelPassword(l10n);
|
|
if (password == null) return; // cancelled
|
|
}
|
|
setState(() => _pendingVoiceChannelId = ch.id);
|
|
try {
|
|
// SDD-106 §1, §6 + SRS-209: Android runtime permission gate.
|
|
// Request RECORD_AUDIO at or before voice_join. On denial or
|
|
// permanent denial we still proceed (listen-only is a
|
|
// first-class mode per SDD-106) but clamp local transmit via
|
|
// setHardMute so the audio engine never opens the capture
|
|
// stream as a sender. On non-Android the service short-circuits
|
|
// to granted and this branch is a no-op.
|
|
//
|
|
// Trace: SDD-106 §1 (request timing), §2 (listen-only on denial),
|
|
// §3 (path to settings on permanent denial), §6
|
|
// (TransmitModeSelector clamp); SRS-209.
|
|
final permState = await _androidPermissions.ensureRecordAudio();
|
|
if (permState != AndroidRecordAudioPermissionState.granted) {
|
|
// Listen-only: clamp hard-mute. The permission_state_banner
|
|
// surfaces the path-to-grant; the user can re-attempt at any
|
|
// time via the Grant / Open Settings action.
|
|
try {
|
|
await rust.setHardMute(muted: true);
|
|
if (mounted) {
|
|
setState(() {
|
|
_hardMute = true;
|
|
_hardMuteByPermission = true;
|
|
});
|
|
}
|
|
} catch (_) {
|
|
// Best-effort clamp; if the bridge isn't ready we still
|
|
// proceed. The capture path also self-clamps on Android
|
|
// when RECORD_AUDIO is not granted (SDD-106 §6 Rust-side,
|
|
// via BridgeEvent::PermissionState → TransmitModeSelector
|
|
// AtomicU8 clamp); this Dart setHardMute is the
|
|
// defence-in-depth path.
|
|
}
|
|
} else if (_hardMuteByPermission) {
|
|
await rust.setHardMute(muted: false);
|
|
if (mounted) {
|
|
setState(() {
|
|
_hardMute = false;
|
|
_hardMuteByPermission = false;
|
|
});
|
|
}
|
|
}
|
|
await rust.voiceJoin(channelId: ch.id, password: password ?? '');
|
|
if (!mounted) return;
|
|
unawaited(_onRefresh());
|
|
} catch (e) {
|
|
if (!mounted) return;
|
|
// Surface as a SnackBar so the user sees it even while
|
|
// connected (the persistent _error string lives in the
|
|
// pre-connect area and is hidden post-connect). The message
|
|
// is selected by TS3 error code per the canonical
|
|
// catalogue at https://github.com/ReSpeak/tsdeclarations.
|
|
final message = _channelJoinErrorMessage(l10n, e);
|
|
setState(() => _pendingVoiceChannelId = null);
|
|
messenger.showSnackBar(
|
|
SnackBar(
|
|
content: Text(message),
|
|
behavior: SnackBarBehavior.floating,
|
|
duration: const Duration(seconds: 4),
|
|
),
|
|
);
|
|
}
|
|
}
|
|
|
|
/// Map a `voiceJoin` error to a localised user-facing message.
|
|
/// Recognises the typed `BridgeError.serverRejected` variant
|
|
/// (with a TS3 error code) and falls back to a generic message
|
|
/// for everything else.
|
|
String _channelJoinErrorMessage(AppL10n l10n, Object e) {
|
|
if (e is rust_err.BridgeError) {
|
|
return e.when(
|
|
invalidCommand: (msg) => l10n.channelJoinFailedGeneric(msg),
|
|
dnsFailed: (host, reason) =>
|
|
l10n.channelJoinFailedGeneric('$host: $reason'),
|
|
connection: (msg) => l10n.channelJoinFailedGeneric(msg),
|
|
notConnected: () => l10n.channelJoinFailedGeneric('not connected'),
|
|
alreadyConnected: () =>
|
|
l10n.channelJoinFailedGeneric('already connected'),
|
|
serverRejected: (code, message) {
|
|
// Canonical TS3 error codes per ReSpeak/tsdeclarations
|
|
// Errors.csv.
|
|
switch (code) {
|
|
case 0x0001:
|
|
// Our sentinel for "snapshot poll didn't confirm".
|
|
return l10n.channelJoinFailedTimeout;
|
|
case 0x0a08: // permissions_client_insufficient
|
|
return l10n.channelJoinFailedPermission;
|
|
case 0x0302: // channel_already_in
|
|
return l10n.channelJoinAlreadyIn;
|
|
case 0x030d: // channel_invalid_password
|
|
return l10n.channelJoinFailedPassword;
|
|
case 0x0309: // channel_maxclients_reached
|
|
return l10n.channelJoinFailedFull;
|
|
case 0x030a: // channel_maxfamily_reached
|
|
return l10n.channelJoinFailedFamilyFull;
|
|
case 0x030e: // channel_is_private_channel
|
|
return l10n.channelJoinFailedPrivate;
|
|
default:
|
|
return l10n.channelJoinFailedGeneric(message);
|
|
}
|
|
},
|
|
unmapped: (msg) => l10n.channelJoinFailedGeneric(msg),
|
|
);
|
|
}
|
|
return l10n.channelJoinFailedGeneric(e.toString());
|
|
}
|
|
|
|
// ignore: unused_element
|
|
Future<void> _onLeaveVoice() async {
|
|
if (!_canLeaveVoiceChannel) return;
|
|
try {
|
|
await rust.voiceLeave();
|
|
} catch (e) {
|
|
if (!mounted) return;
|
|
setState(() => _error = e.toString());
|
|
}
|
|
}
|
|
|
|
Future<void> _onToggleHardMute() async {
|
|
final next = !_hardMute;
|
|
try {
|
|
// Hard-mute is two coordinated effects:
|
|
// * setHardMute — local TransmitGate clamp; we stop sending
|
|
// Opus frames the instant this returns.
|
|
// * setInputMuted — server-side ClientMuted flag so other
|
|
// clients see the mic-off icon next to our name and the
|
|
// server stops relaying any in-flight frames.
|
|
// Sending only one of them is user-confusing; clients see
|
|
// silence but no icon, or icon but a beat of audio leaks
|
|
// through. Drive them together.
|
|
await rust.setHardMute(muted: next);
|
|
await rust.setInputMuted(muted: next);
|
|
if (!mounted) return;
|
|
setState(() {
|
|
_inputMuted = next;
|
|
_hardMuteByPermission = false;
|
|
});
|
|
} catch (e) {
|
|
if (!mounted) return;
|
|
setState(() => _error = e.toString());
|
|
}
|
|
}
|
|
|
|
/// Touch-only PTT (iOS / iPadOS / Android). The on-screen
|
|
/// `_PttHoldButton` calls this with `true` on finger-down and
|
|
/// `false` on finger-up (or cancel). The bridge's
|
|
/// `setPtt(active:)` routes the press edge through the same
|
|
/// release-tail timer + transmit-mode selector the desktop
|
|
/// hardware-key paths use (SDD-096 / SAD-083), so the user-
|
|
/// visible behaviour is identical across platforms — only the
|
|
/// input device changes.
|
|
///
|
|
/// Errors are swallowed silently in the held=false branch
|
|
/// because the timer's `key_up` is idempotent; a failed send
|
|
/// would still let the tail expire naturally. Errors on
|
|
/// held=true surface in the UI banner so the user knows the
|
|
/// mic didn't open.
|
|
Future<void> _onOnscreenPttHeldChanged(bool held) async {
|
|
try {
|
|
await rust.setPtt(active: held);
|
|
} catch (e) {
|
|
if (held) {
|
|
if (!mounted) return;
|
|
setState(() => _error = e.toString());
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Narrow-mode voice controls modal sheet (Plan E status chip
|
|
/// trigger). On mobile this is the **single** voice-controls
|
|
/// surface: route picker + inline mode radio + inline release-tail
|
|
/// slider + level meter + stats + (desktop-only) capability badge.
|
|
/// Zero navigation depth \u2014 no nested dialog.
|
|
Future<void> _onOpenVoiceDetailsSheet() async {
|
|
await showVoiceDetailsSheet(
|
|
context,
|
|
audioStats: _audioStats,
|
|
transmitMode: _transmitMode,
|
|
releaseTailMs: _releaseTailMs,
|
|
pttBoundKeyLabel: _pttBoundKeyLabel,
|
|
pttLevel: _pttLevel,
|
|
pttBackendId: _pttBackendId,
|
|
pttBoundInputClass: _pttBoundInputClass,
|
|
isTouchOnly: _isTouchOnlyPttHost,
|
|
onModeChanged: (mode) async {
|
|
try {
|
|
await rust.setTransmitMode(mode: mode);
|
|
if (!mounted) return;
|
|
setState(() => _transmitMode = mode);
|
|
} catch (e) {
|
|
if (!mounted) return;
|
|
setState(() => _error = e.toString());
|
|
}
|
|
},
|
|
onReleaseTailChanged: (ms) async {
|
|
try {
|
|
await rust.setReleaseTailMs(ms: ms);
|
|
if (!mounted) return;
|
|
setState(() => _releaseTailMs = ms);
|
|
} catch (e) {
|
|
if (!mounted) return;
|
|
setState(() => _error = e.toString());
|
|
}
|
|
},
|
|
);
|
|
}
|
|
|
|
Future<void> _onOpenVoiceSettings() async {
|
|
final result = await showDialog<VoiceSettingsResult>(
|
|
context: context,
|
|
builder: (ctx) => VoiceSettingsDialog(
|
|
initialMode: _transmitMode,
|
|
initialReleaseTailMs: _releaseTailMs,
|
|
),
|
|
);
|
|
if (result == null) return;
|
|
try {
|
|
await rust.setTransmitMode(mode: result.mode);
|
|
await rust.setReleaseTailMs(ms: result.releaseTailMs);
|
|
} catch (e) {
|
|
if (!mounted) return;
|
|
setState(() => _error = e.toString());
|
|
}
|
|
if (result.bindKeyRequested && mounted) {
|
|
await _onConfigurePtt(context);
|
|
if (mounted) {
|
|
unawaited(_onOpenVoiceSettings());
|
|
}
|
|
}
|
|
}
|
|
|
|
Future<String?> _askChannelPassword(AppL10n l10n) async {
|
|
// Same pattern as _onAddCurrentBookmark: route the dialog
|
|
// through a dedicated StatefulWidget so its
|
|
// TextEditingController is disposed at unmount time, not
|
|
// synchronously after `await showDialog` resumes. Inline
|
|
// dispose-after-await caused framework.dart:6268
|
|
// _dependents.isEmpty assertions on iOS \u2014 the controller was
|
|
// torn out while EditableText still depended on InheritedWidgets
|
|
// belonging to the still-popping dialog route.
|
|
return await showDialog<String>(
|
|
context: context,
|
|
builder: (ctx) => const _ChannelPasswordDialog(),
|
|
);
|
|
}
|
|
|
|
Future<void> _onRefresh() async {
|
|
try {
|
|
final snap = await rust.snapshot();
|
|
if (!mounted) return;
|
|
setState(() => _applySnapshot(snap));
|
|
} catch (e) {
|
|
if (!mounted) return;
|
|
setState(() => _error = e.toString());
|
|
}
|
|
}
|
|
|
|
Future<void> _onDisconnect() async {
|
|
_statsTimer?.cancel();
|
|
_statsTimer = null;
|
|
try {
|
|
await rust.disconnect();
|
|
} catch (_) {}
|
|
if (!mounted) return;
|
|
setState(() {
|
|
_phase = _Phase.idle;
|
|
_snapshot = null;
|
|
_audioStarted = false;
|
|
_audioStats = null;
|
|
_error = null;
|
|
_inputMuted = false;
|
|
_outputMuted = false;
|
|
_inChannel = false;
|
|
_currentVoiceChannelId = null;
|
|
_pendingVoiceChannelId = null;
|
|
_canJoinVoiceChannel = true;
|
|
_canLeaveVoiceChannel = false;
|
|
});
|
|
_releaseFocusedPttIfHeld();
|
|
}
|
|
|
|
String _currentVoiceChannelName() {
|
|
final id = _currentVoiceChannelId;
|
|
final snap = _snapshot;
|
|
if (id == null || snap == null) return '';
|
|
for (final ch in snap.channels) {
|
|
if (ch.id == id) return ch.name;
|
|
}
|
|
return '';
|
|
}
|
|
|
|
void _applySnapshot(rust.BridgeSnapshot snap) {
|
|
_snapshot = snap;
|
|
for (final client in snap.clients) {
|
|
if (client.id == snap.ownClientId) {
|
|
_currentVoiceChannelId = client.channel;
|
|
_pendingVoiceChannelId = null;
|
|
_inChannel = true;
|
|
_canJoinVoiceChannel = true;
|
|
_canLeaveVoiceChannel = false;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
Future<void> _onShowDiagnostics(BuildContext context) async {
|
|
final l10n = AppL10n.of(context);
|
|
final text = rust.exportDiagnostics();
|
|
if (!mounted) return;
|
|
await showDialog<void>(
|
|
context: context,
|
|
builder: (ctx) => AlertDialog(
|
|
title: Text(l10n.diagnosticsAction),
|
|
content: SingleChildScrollView(
|
|
child: SelectableText(
|
|
text,
|
|
style: const TextStyle(fontFamily: 'monospace', fontSize: 11),
|
|
),
|
|
),
|
|
actions: [
|
|
TextButton(
|
|
onPressed: () async {
|
|
await Clipboard.setData(ClipboardData(text: text));
|
|
if (!ctx.mounted) return;
|
|
Navigator.of(ctx).pop();
|
|
},
|
|
child: Text(l10n.copyAction),
|
|
),
|
|
TextButton(
|
|
onPressed: () => Navigator.of(ctx).pop(),
|
|
child: Text(l10n.closeAction),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
}
|
|
|
|
Future<void> _onConfigurePtt(BuildContext context) async {
|
|
// On the Linux GNOME-Wayland portal backend, the portal hosts
|
|
// its own system-managed binding dialog (gen2 v0.9.3 / Q3a).
|
|
// Skip the in-app capture dialog entirely on that backend and
|
|
// delegate to the portal via `setPttBinding` with a sentinel
|
|
// platform_key. Show a SnackBar so the user isn't surprised
|
|
// when their compositor opens a separate dialog.
|
|
final l10n = AppL10n.of(context);
|
|
if (!mounted) return;
|
|
if (_pttBackendId == 'gnome-wayland-portal') {
|
|
try {
|
|
final messenger = ScaffoldMessenger.of(context);
|
|
messenger.showSnackBar(
|
|
SnackBar(content: Text(l10n.pttConfigurePortalRedirect)),
|
|
);
|
|
await rust.setPttBinding(
|
|
inputClass: rust.BridgePttInputClass.keyboard,
|
|
platformKey: 'portal',
|
|
);
|
|
} catch (e) {
|
|
if (!mounted) return;
|
|
final messenger = ScaffoldMessenger.of(this.context);
|
|
messenger.showSnackBar(
|
|
SnackBar(content: Text(l10n.statusError(e.toString()))),
|
|
);
|
|
}
|
|
return;
|
|
}
|
|
|
|
// Other backends: open the in-app focus-scoped capture
|
|
// dialog. The bridge carries only the coarse input class and
|
|
// an opaque platform-key string; the actual key value never
|
|
// appears in any log record (DEC-027 / SRS-202).
|
|
final binding = await showDialog<_CapturedBinding>(
|
|
context: context,
|
|
builder: (ctx) => const _PttBindingCaptureDialog(),
|
|
);
|
|
if (binding == null) return;
|
|
try {
|
|
await rust.setPttBinding(
|
|
inputClass: binding.inputClass,
|
|
platformKey: binding.platformKey,
|
|
);
|
|
// Cache the captured label so the badge can surface "Key:
|
|
// Space" / "Key: Mouse4" next to the capability descriptor.
|
|
// The bridge holds the authoritative binding; this is only
|
|
// for display continuity until the next app restart.
|
|
if (mounted) {
|
|
setState(() {
|
|
_pttBoundKeyLabel = binding.platformKey;
|
|
});
|
|
}
|
|
} catch (e) {
|
|
if (!mounted) return;
|
|
// Surface the failure as a snackbar so the user sees that
|
|
// their binding did not stick.
|
|
if (!mounted) return;
|
|
// Use the State's context (guaranteed valid because we
|
|
// re-checked `mounted` immediately above).
|
|
final messenger = ScaffoldMessenger.of(this.context);
|
|
messenger.showSnackBar(
|
|
SnackBar(content: Text(l10n.statusError(e.toString()))),
|
|
);
|
|
}
|
|
}
|
|
|
|
Future<void> _onShowAbout(BuildContext context) async {
|
|
// DEC-018 / DEC-019 / DEC-020 surface: public name, non-
|
|
// affiliation statement, dual-license declaration. The Flutter
|
|
// showAboutDialog widget is intentionally bare so the legal
|
|
// text comes from us, not a framework default.
|
|
final l10n = AppL10n.of(context);
|
|
final theme = Theme.of(context);
|
|
if (!mounted) return;
|
|
await showDialog<void>(
|
|
context: context,
|
|
builder: (ctx) => AlertDialog(
|
|
title: Text(l10n.aboutAction),
|
|
content: SingleChildScrollView(
|
|
child: Column(
|
|
crossAxisAlignment: CrossAxisAlignment.start,
|
|
mainAxisSize: MainAxisSize.min,
|
|
children: [
|
|
Text(l10n.appTitle, style: theme.textTheme.titleLarge),
|
|
const SizedBox(height: 4),
|
|
Text(
|
|
l10n.aboutVersion(_kAppVersion),
|
|
style: theme.textTheme.bodySmall,
|
|
),
|
|
const SizedBox(height: 4),
|
|
Text(l10n.aboutAuthor, style: theme.textTheme.bodySmall),
|
|
const SizedBox(height: 16),
|
|
Text(l10n.aboutNonAffiliation, style: theme.textTheme.bodyMedium),
|
|
const SizedBox(height: 12),
|
|
Text(l10n.aboutLicenseHeading, style: theme.textTheme.titleSmall),
|
|
const SizedBox(height: 4),
|
|
Text(l10n.aboutLicenseBody, style: theme.textTheme.bodySmall),
|
|
const SizedBox(height: 12),
|
|
Text(
|
|
l10n.aboutThirdPartyHeading,
|
|
style: theme.textTheme.titleSmall,
|
|
),
|
|
const SizedBox(height: 4),
|
|
Text(l10n.aboutThirdPartyBody, style: theme.textTheme.bodySmall),
|
|
],
|
|
),
|
|
),
|
|
actions: [
|
|
TextButton(
|
|
onPressed: () async {
|
|
Navigator.of(ctx).pop();
|
|
await _onShowDiagnostics(context);
|
|
},
|
|
child: Text(l10n.diagnosticsAction),
|
|
),
|
|
TextButton(
|
|
onPressed: () => Navigator.of(ctx).pop(),
|
|
child: Text(l10n.closeAction),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
}
|
|
|
|
Future<void> _onAddCurrentBookmark() async {
|
|
// Use the dialog's own context for AppL10n.of(...) inside its
|
|
// builder. Capturing the outer _HomePageState context's l10n in
|
|
// a closure and reading it inside the dialog's widget tree
|
|
// caused the dialog's TextField to depend on InheritedElements
|
|
// (Localizations / _LocalizationsScope) that belong to the
|
|
// outer route. When the dialog popped, the framework
|
|
// deactivated the dialog route's elements first while those
|
|
// outer-route InheritedElements were still alive but had
|
|
// dependents from the disposed dialog tree \u2014 producing the
|
|
// assertion 'package:flutter/src/widgets/framework.dart line
|
|
// 6268 _dependents.isEmpty is not true'.
|
|
//
|
|
// Also: dispose the TextEditingController via the dialog's own
|
|
// StatefulBuilder lifecycle instead of an inline dispose() right
|
|
// after showDialog returns. The inline dispose runs synchronously
|
|
// before the dialog route is fully torn down (the route pop
|
|
// animation is still mid-flight on iOS), and tearing the
|
|
// controller out from under EditableText while it has a live
|
|
// InheritedWidget dependency was the second trigger for the
|
|
// same assertion.
|
|
final initial = _hostCtl.text.trim();
|
|
final name = await showDialog<String>(
|
|
context: context,
|
|
builder: (ctx) => _BookmarkNameDialog(initialName: initial),
|
|
);
|
|
if (name == null || name.trim().isEmpty) return;
|
|
if (!mounted) return;
|
|
try {
|
|
await rust.addBookmark(
|
|
b: rust.BridgeBookmark(
|
|
id: 0,
|
|
displayName: name.trim(),
|
|
host: _hostCtl.text.trim(),
|
|
nickname: _nickCtl.text.trim(),
|
|
password: _passwordCtl.text,
|
|
),
|
|
);
|
|
await _reloadBookmarks();
|
|
} catch (e) {
|
|
if (!mounted) return;
|
|
setState(() => _error = e.toString());
|
|
}
|
|
}
|
|
|
|
Future<void> _onDeleteBookmark(rust.BridgeBookmark b) async {
|
|
try {
|
|
await rust.deleteBookmark(id: b.id);
|
|
await _reloadBookmarks();
|
|
} catch (e) {
|
|
if (!mounted) return;
|
|
setState(() => _error = e.toString());
|
|
}
|
|
}
|
|
|
|
Future<void> _onUseBookmark(rust.BridgeBookmark b) async {
|
|
_hostCtl.text = b.host;
|
|
_nickCtl.text = b.nickname;
|
|
_passwordCtl.text = b.password;
|
|
await _onConnect(host: b.host, nickname: b.nickname, password: b.password);
|
|
}
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
final l10n = AppL10n.of(context);
|
|
final theme = Theme.of(context);
|
|
|
|
String statusText() {
|
|
switch (_phase) {
|
|
case _Phase.idle:
|
|
return _error != null ? l10n.statusError(_error!) : l10n.statusIdle;
|
|
case _Phase.connecting:
|
|
return l10n.statusConnecting;
|
|
case _Phase.connected:
|
|
return l10n.statusConnected(_snapshot?.serverName ?? '');
|
|
}
|
|
}
|
|
|
|
final headerActions = [
|
|
if (_phase == _Phase.connected &&
|
|
_inChannel &&
|
|
MediaQuery.of(context).size.width < 600.0) ...[
|
|
IconButton(
|
|
tooltip: l10n.voiceHardMuteLabel,
|
|
icon: Icon(_hardMute ? Icons.mic_off : Icons.mic),
|
|
isSelected: _hardMute,
|
|
selectedIcon: const Icon(Icons.mic_off),
|
|
onPressed: _onToggleHardMute,
|
|
),
|
|
IconButton(
|
|
tooltip: l10n.voiceOutputMuteLabel,
|
|
icon: Icon(_outputMuted ? Icons.headset_off : Icons.headset),
|
|
isSelected: _outputMuted,
|
|
selectedIcon: const Icon(Icons.headset_off),
|
|
onPressed: _toggleOutputMute,
|
|
),
|
|
],
|
|
IconButton(
|
|
tooltip: l10n.aboutAction,
|
|
icon: const Icon(Icons.info_outline),
|
|
onPressed: () => _onShowAbout(context),
|
|
),
|
|
if (_phase == _Phase.connected) ...[
|
|
IconButton(
|
|
tooltip: l10n.disconnectAction,
|
|
icon: const Icon(Icons.logout),
|
|
onPressed: _onDisconnect,
|
|
),
|
|
],
|
|
];
|
|
|
|
const headerTitle = SizedBox.shrink();
|
|
|
|
final bodyContent = LayoutBuilder(
|
|
builder: (ctx, bodyConstraints) {
|
|
const wideBreakpoint = 600.0;
|
|
final isWideSnapshot =
|
|
bodyConstraints.maxWidth >= wideBreakpoint &&
|
|
_phase == _Phase.connected &&
|
|
_snapshot != null;
|
|
final banner = Container(
|
|
padding: const EdgeInsets.all(10),
|
|
decoration: BoxDecoration(
|
|
color: theme.colorScheme.tertiaryContainer,
|
|
borderRadius: BorderRadius.circular(8),
|
|
),
|
|
child: Text(
|
|
l10n.homeNotProductionReadyBanner,
|
|
style: TextStyle(color: theme.colorScheme.onTertiaryContainer),
|
|
),
|
|
);
|
|
return Column(
|
|
crossAxisAlignment: CrossAxisAlignment.stretch,
|
|
children: [
|
|
if (!isWideSnapshot) ...[banner, const SizedBox(height: 12)],
|
|
Text(statusText(), style: theme.textTheme.titleMedium),
|
|
if (_lostReason != null || _reconnectAttempt != null) ...[
|
|
const SizedBox(height: 8),
|
|
Container(
|
|
padding: const EdgeInsets.all(10),
|
|
decoration: BoxDecoration(
|
|
color: theme.colorScheme.errorContainer,
|
|
borderRadius: BorderRadius.circular(8),
|
|
),
|
|
child: Row(
|
|
children: [
|
|
SizedBox(
|
|
width: 16,
|
|
height: 16,
|
|
child: CircularProgressIndicator(
|
|
strokeWidth: 2,
|
|
color: theme.colorScheme.onErrorContainer,
|
|
),
|
|
),
|
|
const SizedBox(width: 10),
|
|
Expanded(
|
|
child: Text(
|
|
_reconnectAttempt != null
|
|
? l10n.statusReconnecting(
|
|
_reconnectAttempt!,
|
|
_reconnectDelay ?? 0,
|
|
)
|
|
: l10n.statusConnectionLost(_lostReason ?? ''),
|
|
style: TextStyle(
|
|
color: theme.colorScheme.onErrorContainer,
|
|
),
|
|
),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
],
|
|
const SizedBox(height: 12),
|
|
if (_phase == _Phase.idle) ...[
|
|
Expanded(
|
|
child: SingleChildScrollView(
|
|
keyboardDismissBehavior:
|
|
ScrollViewKeyboardDismissBehavior.onDrag,
|
|
child: Column(
|
|
crossAxisAlignment: CrossAxisAlignment.stretch,
|
|
children: [
|
|
_ConnectForm(
|
|
hostCtl: _hostCtl,
|
|
nickCtl: _nickCtl,
|
|
passwordCtl: _passwordCtl,
|
|
onConnect: () => _onConnect(),
|
|
onAddBookmark: _onAddCurrentBookmark,
|
|
),
|
|
const SizedBox(height: 16),
|
|
_BookmarkList(
|
|
bookmarks: _bookmarks,
|
|
onConnect: _onUseBookmark,
|
|
onDelete: _onDeleteBookmark,
|
|
),
|
|
],
|
|
),
|
|
),
|
|
),
|
|
] else if (_phase == _Phase.connecting) ...[
|
|
const Center(
|
|
child: Padding(
|
|
padding: EdgeInsets.all(32),
|
|
child: CircularProgressIndicator(),
|
|
),
|
|
),
|
|
] else if (_phase == _Phase.connected && _snapshot != null) ...[
|
|
Expanded(
|
|
child: LayoutBuilder(
|
|
builder: (ctx, constraints) {
|
|
final voiceBar = VoiceBar(
|
|
inChannel: _inChannel,
|
|
transmitMode: _transmitMode,
|
|
hardMute: _hardMute,
|
|
outputMuted: _outputMuted,
|
|
releaseTailMs: _releaseTailMs,
|
|
channelName: _currentVoiceChannelName(),
|
|
audioStats: _audioStats,
|
|
pttLevel: _pttLevel,
|
|
pttBackendId: _pttBackendId,
|
|
pttBoundInputClass: _pttBoundInputClass,
|
|
pttBoundKeyLabel: _pttBoundKeyLabel,
|
|
onToggleMute: _onToggleHardMute,
|
|
onToggleOutputMute: _toggleOutputMute,
|
|
onConfigure: _onOpenVoiceSettings,
|
|
onPttHeldChanged: _onOnscreenPttHeldChanged,
|
|
);
|
|
// SDD-106 §2/§3 + SRS-209: listen-only banner.
|
|
// Self-hides on granted / unknown / non-Android.
|
|
final permissionBanner = PermissionStateBanner(
|
|
service: _androidPermissions,
|
|
);
|
|
final snapshotView = _SnapshotView(
|
|
snapshot: _snapshot!,
|
|
currentVoiceChannelId: _currentVoiceChannelId,
|
|
pendingVoiceChannelId: _pendingVoiceChannelId,
|
|
hasJoinPending: _pendingVoiceChannelId != null,
|
|
canJoinVoiceChannel: _canJoinVoiceChannel,
|
|
onJoinChannel: (ch) => _onJoinChannel(ch),
|
|
onJoinChannelWithPassword: (ch) =>
|
|
_onJoinChannel(ch, askForPassword: true),
|
|
);
|
|
const voiceBarWidthWide = 320.0;
|
|
if (constraints.maxWidth >= wideBreakpoint) {
|
|
return Row(
|
|
crossAxisAlignment: CrossAxisAlignment.stretch,
|
|
children: [
|
|
SizedBox(
|
|
width: voiceBarWidthWide,
|
|
child: Column(
|
|
crossAxisAlignment: CrossAxisAlignment.stretch,
|
|
children: [
|
|
banner,
|
|
const SizedBox(height: 12),
|
|
permissionBanner,
|
|
voiceBar,
|
|
],
|
|
),
|
|
),
|
|
const SizedBox(width: 12),
|
|
Expanded(child: snapshotView),
|
|
],
|
|
);
|
|
}
|
|
return Column(
|
|
crossAxisAlignment: CrossAxisAlignment.stretch,
|
|
children: [
|
|
Expanded(child: snapshotView),
|
|
const SizedBox(height: 8),
|
|
permissionBanner,
|
|
VoiceStatusChip(
|
|
transmitMode: _transmitMode,
|
|
releaseTailMs: _releaseTailMs,
|
|
pttBoundKeyLabel: _pttBoundKeyLabel,
|
|
audioStats: _audioStats,
|
|
isTouchOnly: _isTouchOnlyPttHost,
|
|
onTap: () => _onOpenVoiceDetailsSheet(),
|
|
),
|
|
if (_inChannel &&
|
|
_transmitMode == rust.BridgeTransmitMode.ptt) ...[
|
|
const SizedBox(height: 8),
|
|
VoicePttButton(
|
|
active: _audioStats?.pttActive ?? false,
|
|
onHeldChanged: _onOnscreenPttHeldChanged,
|
|
),
|
|
],
|
|
],
|
|
);
|
|
},
|
|
),
|
|
),
|
|
],
|
|
],
|
|
);
|
|
},
|
|
);
|
|
|
|
if (_isMacOS) {
|
|
return Scaffold(
|
|
body: Padding(
|
|
padding: const EdgeInsets.only(top: _macOSTrafficLightPad),
|
|
child: Column(
|
|
children: [
|
|
Padding(
|
|
padding: const EdgeInsets.symmetric(horizontal: 16),
|
|
child: Row(
|
|
children: [
|
|
Expanded(child: headerTitle),
|
|
...headerActions,
|
|
],
|
|
),
|
|
),
|
|
Expanded(
|
|
child: Padding(
|
|
padding: const EdgeInsets.all(16),
|
|
child: bodyContent,
|
|
),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
);
|
|
}
|
|
|
|
return Scaffold(
|
|
appBar: AppBar(title: headerTitle, actions: headerActions),
|
|
body: Padding(padding: const EdgeInsets.all(16), child: bodyContent),
|
|
);
|
|
}
|
|
}
|
|
|
|
/// 'Save bookmark' name-entry dialog. Owns its own
|
|
/// TextEditingController via a StatefulWidget lifecycle so the
|
|
/// dispose() runs cleanly at unmount time (after the route pop
|
|
/// animation has fully detached the dialog subtree), not
|
|
/// synchronously from the caller's `await showDialog` resumption
|
|
/// point.
|
|
///
|
|
/// Inline dispose-after-showDialog pattern previously caused
|
|
/// 'framework.dart line 6268 _dependents.isEmpty' on iOS because
|
|
/// the controller was torn down mid-pop while EditableText still
|
|
/// had live InheritedWidget dependencies on the dialog route.
|
|
class _BookmarkNameDialog extends StatefulWidget {
|
|
const _BookmarkNameDialog({required this.initialName});
|
|
|
|
final String initialName;
|
|
|
|
@override
|
|
State<_BookmarkNameDialog> createState() => _BookmarkNameDialogState();
|
|
}
|
|
|
|
class _BookmarkNameDialogState extends State<_BookmarkNameDialog> {
|
|
late final TextEditingController _ctl = TextEditingController(
|
|
text: widget.initialName,
|
|
);
|
|
|
|
@override
|
|
void dispose() {
|
|
_ctl.dispose();
|
|
super.dispose();
|
|
}
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
final l10n = AppL10n.of(context);
|
|
return AlertDialog(
|
|
title: Text(l10n.bookmarkAddTitle),
|
|
content: TextField(
|
|
controller: _ctl,
|
|
autofocus: true,
|
|
decoration: InputDecoration(labelText: l10n.fieldDisplayName),
|
|
onSubmitted: (_) => Navigator.of(context).pop(_ctl.text),
|
|
),
|
|
actions: [
|
|
TextButton(
|
|
onPressed: () => Navigator.of(context).pop(),
|
|
child: Text(l10n.closeAction),
|
|
),
|
|
FilledButton(
|
|
onPressed: () => Navigator.of(context).pop(_ctl.text),
|
|
child: Text(l10n.bookmarkAddAction),
|
|
),
|
|
],
|
|
);
|
|
}
|
|
}
|
|
|
|
/// Channel-password dialog. Same StatefulWidget pattern as
|
|
/// [_BookmarkNameDialog] to keep TextEditingController disposal
|
|
/// inside the dialog's own lifecycle and avoid the
|
|
/// framework.dart:6268 _dependents.isEmpty assertion.
|
|
class _ChannelPasswordDialog extends StatefulWidget {
|
|
const _ChannelPasswordDialog();
|
|
|
|
@override
|
|
State<_ChannelPasswordDialog> createState() => _ChannelPasswordDialogState();
|
|
}
|
|
|
|
class _ChannelPasswordDialogState extends State<_ChannelPasswordDialog> {
|
|
final TextEditingController _ctl = TextEditingController();
|
|
|
|
@override
|
|
void dispose() {
|
|
_ctl.dispose();
|
|
super.dispose();
|
|
}
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
final l10n = AppL10n.of(context);
|
|
return AlertDialog(
|
|
title: Text(l10n.channelPasswordTitle),
|
|
content: TextField(
|
|
controller: _ctl,
|
|
obscureText: true,
|
|
autofocus: true,
|
|
decoration: InputDecoration(labelText: l10n.fieldPassword),
|
|
onSubmitted: (_) => Navigator.of(context).pop(_ctl.text),
|
|
),
|
|
actions: [
|
|
TextButton(
|
|
onPressed: () => Navigator.of(context).pop(),
|
|
child: Text(l10n.closeAction),
|
|
),
|
|
FilledButton(
|
|
onPressed: () => Navigator.of(context).pop(_ctl.text),
|
|
child: Text(l10n.connectAction),
|
|
),
|
|
],
|
|
);
|
|
}
|
|
}
|
|
|
|
class _ConnectForm extends StatefulWidget {
|
|
const _ConnectForm({
|
|
required this.hostCtl,
|
|
required this.nickCtl,
|
|
required this.passwordCtl,
|
|
required this.onConnect,
|
|
required this.onAddBookmark,
|
|
});
|
|
|
|
final TextEditingController hostCtl;
|
|
final TextEditingController nickCtl;
|
|
final TextEditingController passwordCtl;
|
|
final VoidCallback onConnect;
|
|
final VoidCallback onAddBookmark;
|
|
|
|
@override
|
|
State<_ConnectForm> createState() => _ConnectFormState();
|
|
}
|
|
|
|
class _ConnectFormState extends State<_ConnectForm> {
|
|
// FocusNodes + Listener(onPointerDown) wrappers fix a Flutter-on-
|
|
// iOS gesture-arena issue where enclosing scrollables (in our
|
|
// case, the SingleChildScrollView wrapping the connect form, and
|
|
// the ListView wrapping the channel tree) absorb the first tap
|
|
// as a possible scroll-intent. The second tap then succeeds
|
|
// because the scrollable's tap-arena participant has already
|
|
// decided not to handle a drag.
|
|
//
|
|
// Two-layer fix:
|
|
// * focusNode + autofocus-on-tap inside TextField — works when
|
|
// the arena resolves the tap as a TextField gesture
|
|
// * Listener(onPointerDown) wrapping the TextField with
|
|
// HitTestBehavior.translucent — fires synchronously on
|
|
// pointer-down BEFORE arena resolution, so even if the
|
|
// scrollable were to win the arena we have already grabbed
|
|
// focus. Translucent means the pointer ALSO propagates down
|
|
// to the TextField so its normal touch handling still runs.
|
|
//
|
|
// This is the documented workaround in
|
|
// https://github.com/flutter/flutter/issues/22680 and many
|
|
// related arena-race threads.
|
|
final FocusNode _hostFocus = FocusNode();
|
|
final FocusNode _nickFocus = FocusNode();
|
|
final FocusNode _passwordFocus = FocusNode();
|
|
|
|
// _kickFocus (unfocus + Future.microtask refocus on every onTap)
|
|
// was removed after user-reported 500\u20131000 ms keyboard appearance
|
|
// latency on iPhone 16 Pro / iOS 26.
|
|
//
|
|
// The microtask deferral was the source of the lag: it forces
|
|
// EditableText's attach-to-TextInput path to wait one frame past
|
|
// the user's pointer-up, and iOS 26's keyboard slide-up animation
|
|
// then dovetails into that extra frame in a way that adds another
|
|
// 200\u2013800 ms before the keyboard actually appears.
|
|
//
|
|
// The tap-outside-to-unfocus GestureDetector wrapping the connect
|
|
// form Column (see build() below) already guarantees the FocusNode
|
|
// is in the unfocused state when the user taps a field, because
|
|
// any prior keyboard dismissal (tap outside / tap a sibling field)
|
|
// goes through FocusScope.unfocus(). Therefore TextField's native
|
|
// tap path can attach TextInput on the first frame with no help
|
|
// from us, and the keyboard appears instantly.
|
|
//
|
|
// If iOS regresses again such that focus state desyncs from
|
|
// keyboard visibility, the workaround to re-introduce here is the
|
|
// canonical pattern from flutter/flutter#181474:
|
|
//
|
|
// void _kickFocus(FocusNode node) {
|
|
// if (node.hasFocus) node.unfocus();
|
|
// Future.microtask(() {
|
|
// if (!mounted) return;
|
|
// node.requestFocus();
|
|
// });
|
|
// }
|
|
//
|
|
// and wire onTap: () => _kickFocus(_xxxFocus) on each TextField.
|
|
|
|
/// Dismisses the soft keyboard when the user taps outside any
|
|
/// TextField in this form. Wired into each TextField via the
|
|
/// built-in `onTapOutside` parameter (Flutter 3.10+), which uses
|
|
/// the framework's TapRegion machinery to detect taps outside the
|
|
/// field's region without us having to install an outer
|
|
/// GestureDetector (which previously caused a
|
|
/// '_dependents.isEmpty' assertion when modal-sheet pop sequences
|
|
/// raced the InheritedWidget dependency cleanup).
|
|
///
|
|
/// Uses FocusManager.instance \u2014 a global singleton with no
|
|
/// BuildContext dependency \u2014 instead of FocusScope.of(context),
|
|
/// to avoid subscribing this widget's Element to any
|
|
/// InheritedWidget.
|
|
void _onTapOutside(PointerDownEvent _) {
|
|
FocusManager.instance.primaryFocus?.unfocus();
|
|
}
|
|
|
|
@override
|
|
void dispose() {
|
|
_hostFocus.dispose();
|
|
_nickFocus.dispose();
|
|
_passwordFocus.dispose();
|
|
super.dispose();
|
|
}
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
final l10n = AppL10n.of(context);
|
|
// Tap-outside-to-unfocus.
|
|
//
|
|
// Iteration history:
|
|
// * 020be77/23bd1c7: Listener pre-arena requestFocus +
|
|
// SystemChannels.textInput.show. Caused first-tap-not-focusing
|
|
// AND post-attach keystroke lag (Listener wins arena,
|
|
// EditableText loses).
|
|
// * 79f8360: _kickFocus(unfocus + Future.microtask refocus) on
|
|
// every TextField.onTap. Caused 500-1000 ms keyboard slide-up
|
|
// lag (microtask deferral collides with iOS keyboard
|
|
// CAAnimation).
|
|
// * 6955547: GestureDetector(HitTestBehavior.opaque, onTap:
|
|
// FocusScope.of(context).unfocus()) wrapping the Column.
|
|
// Caused 'package:flutter/src/widgets/framework.dart line
|
|
// 6268 _dependents.isEmpty' assertion: the
|
|
// FocusScope.of(context) call subscribes the GestureDetector's
|
|
// Element to the _FocusScopeMarker InheritedWidget on every
|
|
// build, and the modal-sheet pop sequence deactivates that
|
|
// InheritedElement before the dependents fully clear,
|
|
// tripping the debug assert.
|
|
//
|
|
// Current approach (no outer GestureDetector at all):
|
|
// * Use TextField.onTapOutside (added Flutter 3.10+). Wired
|
|
// per field. Uses FocusManager.instance (global, no
|
|
// BuildContext dependency, no InheritedWidget race).
|
|
// * iOS framework default for touch+mobile is to do NOTHING
|
|
// on tap-outside (see flutter/widgets/editable_text.dart
|
|
// _EditableTextTapOutsideAction:6748-6755) because the iOS
|
|
// UX convention is 'swipe-down on the keyboard' or 'tap
|
|
// Done' \u2014 not tap-outside. We override that explicitly
|
|
// because most users expect tap-outside-to-dismiss in a
|
|
// server-connect form context.
|
|
// * No outer GestureDetector means zero gesture-arena
|
|
// interference with the TextField's own tap recognizer \u2014
|
|
// keyboard appears synchronously on first tap, no lag.
|
|
return Column(
|
|
crossAxisAlignment: CrossAxisAlignment.stretch,
|
|
children: [
|
|
TextField(
|
|
controller: widget.hostCtl,
|
|
focusNode: _hostFocus,
|
|
onTapOutside: _onTapOutside,
|
|
// Server addresses are URL-shaped: hostname or
|
|
// hostname:port, all-lowercase ASCII, never user-
|
|
// friendly prose. Configure the on-screen keyboard
|
|
// accordingly:
|
|
// * keyboardType: .url \u2014 surfaces ".", "/",
|
|
// ":" on the primary keyboard plane so the user
|
|
// doesn't have to switch to the symbols pane to
|
|
// type kr.teamspeak.app:9987.
|
|
// * textInputAction: .next \u2014 return key advances
|
|
// to the nickname field.
|
|
// * autocorrect / enableSuggestions: false \u2014 iOS
|
|
// should not autocorrect 'kr.teamspeak.app' to
|
|
// 'kr.teamspeak.lap' or suggest 'KR' in caps.
|
|
// * textCapitalization: .none \u2014 don't capitalise the
|
|
// first letter the way iOS does for sentences.
|
|
// * inputFormatters: deny whitespace and uppercase\u2014
|
|
// belt-and-braces in case the user pastes from a
|
|
// formatted source (e.g. tab-indented copy).
|
|
keyboardType: TextInputType.url,
|
|
textCapitalization: TextCapitalization.none,
|
|
textInputAction: TextInputAction.next,
|
|
autocorrect: false,
|
|
enableSuggestions: false,
|
|
inputFormatters: [
|
|
FilteringTextInputFormatter.deny(RegExp(r'\s')),
|
|
TextInputFormatter.withFunction(
|
|
(oldValue, newValue) => newValue.copyWith(
|
|
text: newValue.text.toLowerCase(),
|
|
selection: newValue.selection,
|
|
),
|
|
),
|
|
],
|
|
decoration: InputDecoration(
|
|
labelText: l10n.fieldServerHost,
|
|
hintText: 'host[:port]',
|
|
prefixIcon: const Icon(Icons.dns_outlined),
|
|
border: const OutlineInputBorder(),
|
|
),
|
|
),
|
|
const SizedBox(height: 8),
|
|
TextField(
|
|
controller: widget.nickCtl,
|
|
focusNode: _nickFocus,
|
|
onTapOutside: _onTapOutside,
|
|
textInputAction: TextInputAction.next,
|
|
autocorrect: false,
|
|
enableSuggestions: false,
|
|
decoration: InputDecoration(
|
|
labelText: l10n.fieldNickname,
|
|
border: const OutlineInputBorder(),
|
|
),
|
|
),
|
|
const SizedBox(height: 8),
|
|
TextField(
|
|
controller: widget.passwordCtl,
|
|
focusNode: _passwordFocus,
|
|
onTapOutside: _onTapOutside,
|
|
obscureText: true,
|
|
textInputAction: TextInputAction.done,
|
|
autocorrect: false,
|
|
enableSuggestions: false,
|
|
decoration: InputDecoration(
|
|
labelText: l10n.fieldServerPassword,
|
|
helperText: l10n.fieldServerPasswordHelp,
|
|
border: const OutlineInputBorder(),
|
|
),
|
|
),
|
|
const SizedBox(height: 16),
|
|
Row(
|
|
children: [
|
|
Expanded(
|
|
child: FilledButton.icon(
|
|
icon: const Icon(Icons.login),
|
|
label: Text(l10n.connectAction),
|
|
onPressed: widget.onConnect,
|
|
),
|
|
),
|
|
const SizedBox(width: 8),
|
|
OutlinedButton.icon(
|
|
icon: const Icon(Icons.bookmark_add_outlined),
|
|
label: Text(l10n.bookmarkAddAction),
|
|
onPressed: widget.onAddBookmark,
|
|
),
|
|
],
|
|
),
|
|
],
|
|
);
|
|
}
|
|
}
|
|
|
|
class _BookmarkList extends StatelessWidget {
|
|
const _BookmarkList({
|
|
required this.bookmarks,
|
|
required this.onConnect,
|
|
required this.onDelete,
|
|
});
|
|
|
|
final List<rust.BridgeBookmark> bookmarks;
|
|
final ValueChanged<rust.BridgeBookmark> onConnect;
|
|
final ValueChanged<rust.BridgeBookmark> onDelete;
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
final l10n = AppL10n.of(context);
|
|
final theme = Theme.of(context);
|
|
if (bookmarks.isEmpty) {
|
|
return Padding(
|
|
padding: const EdgeInsets.symmetric(vertical: 8),
|
|
child: Text(l10n.bookmarksEmpty, style: theme.textTheme.bodySmall),
|
|
);
|
|
}
|
|
return Column(
|
|
crossAxisAlignment: CrossAxisAlignment.stretch,
|
|
children: [
|
|
Text(l10n.bookmarksHeading, style: theme.textTheme.titleSmall),
|
|
const SizedBox(height: 4),
|
|
for (final b in bookmarks)
|
|
Card(
|
|
margin: const EdgeInsets.symmetric(vertical: 4),
|
|
child: ListTile(
|
|
title: Text(b.displayName),
|
|
subtitle: Text('${b.host} — ${b.nickname}'),
|
|
trailing: Row(
|
|
mainAxisSize: MainAxisSize.min,
|
|
children: [
|
|
IconButton(
|
|
icon: const Icon(Icons.login),
|
|
tooltip: l10n.connectAction,
|
|
onPressed: () => onConnect(b),
|
|
),
|
|
IconButton(
|
|
icon: const Icon(Icons.delete_outline),
|
|
tooltip: l10n.bookmarkDeleteAction,
|
|
onPressed: () => onDelete(b),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
),
|
|
],
|
|
);
|
|
}
|
|
}
|
|
|
|
/// PTT capability badge (gen2 v0.9.3 / SDD-091).
|
|
///
|
|
/// Renders the active PTT level + backend in the Voice Bar so the
|
|
/// user understands which input path is in effect. When the
|
|
/// resolved capability is `L0Focused` an info icon appears that
|
|
/// opens a per-platform explanation sheet describing why Global
|
|
/// PTT is not active and what the user can do to engage it.
|
|
///
|
|
/// Driven by the `BridgeEvent::PttCapability` stream published by
|
|
/// the `PttController` (SDD-088). The `_BetaHomeState` listener
|
|
/// updates the props on each transition.
|
|
class PttCapabilityBadge extends StatelessWidget {
|
|
/// Construct a badge.
|
|
const PttCapabilityBadge({
|
|
super.key,
|
|
required this.level,
|
|
required this.backendId,
|
|
required this.boundInputClass,
|
|
});
|
|
|
|
/// Resolved capability level as the bridge emits it
|
|
/// (`L0Focused` / `L1WindowsHook` / `L2WindowsRawInput` /
|
|
/// `L1MacOSEventTap` / `L1LinuxGnomeWaylandPortal`).
|
|
final String level;
|
|
|
|
/// Stable backend identifier (`focused`, `windows-raw-input`, …).
|
|
final String backendId;
|
|
|
|
/// Privacy-safe input class (`keyboard`, `mouse-side-button`,
|
|
/// or empty when no binding is set).
|
|
final String boundInputClass;
|
|
|
|
bool get _isFocused => level == 'L0Focused';
|
|
|
|
String _explainBodyForPlatform(AppL10n l10n) {
|
|
// Use `defaultTargetPlatform` rather than `Theme.of(context).platform`
|
|
// because the latter is influenced by debug platform overrides
|
|
// that callers may toggle in dev mode. We want the badge's
|
|
// explanation to match the actual host OS.
|
|
switch (defaultTargetPlatform) {
|
|
case TargetPlatform.windows:
|
|
return l10n.pttCapabilityExplainGoGlobalWindows;
|
|
case TargetPlatform.macOS:
|
|
return l10n.pttCapabilityExplainGoGlobalMacos;
|
|
case TargetPlatform.linux:
|
|
return l10n.pttCapabilityExplainGoGlobalLinux;
|
|
case TargetPlatform.iOS:
|
|
return l10n.pttCapabilityExplainGoGlobalIos;
|
|
default:
|
|
return l10n.pttCapabilityExplainGoGlobalGeneric;
|
|
}
|
|
}
|
|
|
|
void _openExplanationSheet(BuildContext context) {
|
|
final l10n = AppL10n.of(context);
|
|
showModalBottomSheet<void>(
|
|
context: context,
|
|
showDragHandle: true,
|
|
builder: (sheetContext) {
|
|
final theme = Theme.of(sheetContext);
|
|
return SafeArea(
|
|
child: Padding(
|
|
padding: const EdgeInsets.fromLTRB(20, 4, 20, 24),
|
|
child: Column(
|
|
mainAxisSize: MainAxisSize.min,
|
|
crossAxisAlignment: CrossAxisAlignment.start,
|
|
children: [
|
|
Text(
|
|
l10n.pttCapabilityExplainTitle,
|
|
style: theme.textTheme.titleMedium,
|
|
),
|
|
const SizedBox(height: 12),
|
|
Text(
|
|
l10n.pttCapabilityExplainFocusedHeading,
|
|
style: theme.textTheme.titleSmall,
|
|
),
|
|
const SizedBox(height: 4),
|
|
Text(
|
|
l10n.pttCapabilityExplainFocusedBody,
|
|
style: theme.textTheme.bodyMedium,
|
|
),
|
|
const SizedBox(height: 16),
|
|
Text(
|
|
_explainBodyForPlatform(l10n),
|
|
style: theme.textTheme.bodyMedium,
|
|
),
|
|
const SizedBox(height: 16),
|
|
Align(
|
|
alignment: AlignmentDirectional.centerEnd,
|
|
child: TextButton(
|
|
onPressed: () => Navigator.of(sheetContext).pop(),
|
|
child: Text(l10n.closeAction),
|
|
),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
);
|
|
},
|
|
);
|
|
}
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
final l10n = AppL10n.of(context);
|
|
final theme = Theme.of(context);
|
|
final badgeLabel = l10n.pttCapabilityBadge(level, backendId);
|
|
final tooltipMessage = boundInputClass.isEmpty
|
|
? badgeLabel
|
|
: '$badgeLabel\n($boundInputClass)';
|
|
return Padding(
|
|
padding: const EdgeInsets.only(bottom: 6),
|
|
child: Tooltip(
|
|
message: tooltipMessage,
|
|
child: Row(
|
|
children: [
|
|
Icon(
|
|
_isFocused ? Icons.crop_free : Icons.public,
|
|
size: 14,
|
|
color: theme.colorScheme.onSurfaceVariant,
|
|
),
|
|
const SizedBox(width: 4),
|
|
Expanded(
|
|
child: Text(
|
|
badgeLabel,
|
|
style: theme.textTheme.bodySmall?.copyWith(
|
|
color: theme.colorScheme.onSurfaceVariant,
|
|
),
|
|
),
|
|
),
|
|
// Info icon only for L0Focused — the explanation sheet
|
|
// tells the user why their PTT may not work outside the
|
|
// app window and how to grant the permission. There is
|
|
// intentionally NO 'Configure' button here: the single
|
|
// configuration entry point is the Voice Bar's
|
|
// settings gear (onConfigure on `VoiceBar`). Having two
|
|
// identical bind-key entry points just confuses users.
|
|
if (_isFocused)
|
|
IconButton(
|
|
icon: const Icon(Icons.info_outline, size: 16),
|
|
tooltip: l10n.pttCapabilityExplainTitle,
|
|
visualDensity: VisualDensity.compact,
|
|
onPressed: () => _openExplanationSheet(context),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
);
|
|
}
|
|
}
|
|
|
|
class _SnapshotView extends StatelessWidget {
|
|
const _SnapshotView({
|
|
required this.snapshot,
|
|
required this.currentVoiceChannelId,
|
|
required this.pendingVoiceChannelId,
|
|
required this.hasJoinPending,
|
|
required this.canJoinVoiceChannel,
|
|
required this.onJoinChannel,
|
|
required this.onJoinChannelWithPassword,
|
|
});
|
|
|
|
final rust.BridgeSnapshot snapshot;
|
|
final BigInt? currentVoiceChannelId;
|
|
final BigInt? pendingVoiceChannelId;
|
|
final bool hasJoinPending;
|
|
final bool canJoinVoiceChannel;
|
|
final ValueChanged<rust.BridgeChannel> onJoinChannel;
|
|
final ValueChanged<rust.BridgeChannel> onJoinChannelWithPassword;
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
final l10n = AppL10n.of(context);
|
|
final theme = Theme.of(context);
|
|
|
|
// Channels arrive pre-sorted from the bridge: the Rust
|
|
// adapter (chanora_protocol::adapter::sort_channels_tree)
|
|
// emits them in root-first depth-first order following the
|
|
// TeamSpeak linked-list `order` predecessor pointers. We
|
|
// therefore trust the server order verbatim — re-sorting by
|
|
// `order` numerically here would re-introduce the bug fixed
|
|
// in that adapter (TS3 `order` is NOT a numeric rank).
|
|
final channels = snapshot.channels;
|
|
|
|
// Compute each channel's depth in the parent hierarchy so we
|
|
// can render it indented. Root channels (parent == 0) are
|
|
// depth 0; their children depth 1; and so on. Depth caps at
|
|
// 6 to keep the indent visually bounded on deeply-nested
|
|
// servers (the cap plateaus silently — no glyph; the channel
|
|
// is still tappable and its real depth lives in the data).
|
|
final depthById = <BigInt, int>{};
|
|
final zero = BigInt.zero;
|
|
for (final ch in channels) {
|
|
if (ch.parent == zero) {
|
|
depthById[ch.id] = 0;
|
|
} else {
|
|
final parentDepth = depthById[ch.parent] ?? 0;
|
|
depthById[ch.id] = (parentDepth + 1).clamp(0, 6);
|
|
}
|
|
}
|
|
const indentPerLevel = 18.0;
|
|
|
|
final byChannel = <BigInt, List<rust.BridgeClient>>{};
|
|
for (final c in snapshot.clients) {
|
|
byChannel.putIfAbsent(c.channel, () => []).add(c);
|
|
}
|
|
|
|
return ListView(
|
|
children: [
|
|
Text(
|
|
l10n.countChannelsAndClients(
|
|
snapshot.channels.length,
|
|
snapshot.clients.length,
|
|
),
|
|
style: theme.textTheme.bodyMedium,
|
|
),
|
|
if (snapshot.welcomeMessage.isNotEmpty) ...[
|
|
const SizedBox(height: 8),
|
|
Container(
|
|
padding: const EdgeInsets.all(8),
|
|
decoration: BoxDecoration(
|
|
color: theme.colorScheme.surfaceContainerHighest,
|
|
borderRadius: BorderRadius.circular(6),
|
|
),
|
|
child: Text(
|
|
snapshot.welcomeMessage,
|
|
style: theme.textTheme.bodySmall,
|
|
),
|
|
),
|
|
],
|
|
const Divider(height: 24),
|
|
Text(l10n.channelsHeading, style: theme.textTheme.titleMedium),
|
|
const SizedBox(height: 4),
|
|
for (final ch in channels) ...[
|
|
Padding(
|
|
padding: EdgeInsets.only(
|
|
left: (depthById[ch.id] ?? 0) * indentPerLevel,
|
|
),
|
|
child: ListTile(
|
|
dense: true,
|
|
leading: Icon(
|
|
ch.id == currentVoiceChannelId ? Icons.volume_up : Icons.tag,
|
|
),
|
|
title: Text(ch.name),
|
|
subtitle: Text('id=${ch.id} parent=${ch.parent}'),
|
|
trailing: ch.hasPassword && ch.id != currentVoiceChannelId
|
|
? Tooltip(
|
|
message: l10n.channelPasswordTitle,
|
|
child: Icon(
|
|
Icons.lock_outline,
|
|
color: theme.colorScheme.onSurfaceVariant,
|
|
),
|
|
)
|
|
: null,
|
|
selected: ch.id == currentVoiceChannelId,
|
|
onTap:
|
|
hasJoinPending ||
|
|
!canJoinVoiceChannel ||
|
|
ch.id == currentVoiceChannelId
|
|
? null
|
|
: () => ch.hasPassword
|
|
? onJoinChannelWithPassword(ch)
|
|
: onJoinChannel(ch),
|
|
),
|
|
),
|
|
for (final cl in byChannel[ch.id] ?? const <rust.BridgeClient>[])
|
|
Padding(
|
|
padding: EdgeInsets.only(
|
|
left: ((depthById[ch.id] ?? 0) * indentPerLevel) + 64,
|
|
),
|
|
child: ListTile(
|
|
dense: true,
|
|
visualDensity: VisualDensity.compact,
|
|
leading: Icon(
|
|
cl.isServerQuery ? Icons.terminal : Icons.person,
|
|
size: 18,
|
|
),
|
|
title: Text(
|
|
cl.name,
|
|
style: cl.isServerQuery
|
|
? TextStyle(color: theme.colorScheme.onSurfaceVariant)
|
|
: null,
|
|
),
|
|
),
|
|
),
|
|
],
|
|
],
|
|
);
|
|
}
|
|
}
|
|
|
|
/// Result of a successful PTT binding capture. Carries only the
|
|
/// coarse input class and an opaque platform-key label —
|
|
/// per DEC-027 the actual key code never crosses out of the
|
|
/// capture dialog.
|
|
class _CapturedBinding {
|
|
const _CapturedBinding({required this.inputClass, required this.platformKey});
|
|
final rust.BridgePttInputClass inputClass;
|
|
final String platformKey;
|
|
}
|
|
|
|
/// Focus-scoped dialog that captures the next key press or mouse
|
|
/// side-button click and returns it as a `_CapturedBinding`. The
|
|
/// captured value is the platform-neutral `LogicalKeyboardKey`
|
|
/// debug label or `"mouse-side-button:{button}"`; the platform
|
|
/// backend interprets the string and never logs it.
|
|
class _PttBindingCaptureDialog extends StatefulWidget {
|
|
const _PttBindingCaptureDialog();
|
|
|
|
@override
|
|
State<_PttBindingCaptureDialog> createState() =>
|
|
_PttBindingCaptureDialogState();
|
|
}
|
|
|
|
class _PttBindingCaptureDialogState extends State<_PttBindingCaptureDialog> {
|
|
final FocusNode _focusNode = FocusNode();
|
|
String? _captured;
|
|
rust.BridgePttInputClass _capturedClass = rust.BridgePttInputClass.none;
|
|
|
|
@override
|
|
void initState() {
|
|
super.initState();
|
|
WidgetsBinding.instance.addPostFrameCallback((_) {
|
|
_focusNode.requestFocus();
|
|
});
|
|
}
|
|
|
|
@override
|
|
void dispose() {
|
|
_focusNode.dispose();
|
|
super.dispose();
|
|
}
|
|
|
|
KeyEventResult _onKeyEvent(FocusNode node, KeyEvent event) {
|
|
if (event is! KeyDownEvent) return KeyEventResult.ignored;
|
|
final label = _pttDisplayLabelForKey(event.logicalKey);
|
|
if (label == null) return KeyEventResult.ignored;
|
|
setState(() {
|
|
_captured = label;
|
|
_capturedClass = rust.BridgePttInputClass.keyboard;
|
|
});
|
|
return KeyEventResult.handled;
|
|
}
|
|
|
|
void _captureMouseSideButton(int button) {
|
|
setState(() {
|
|
_captured = 'mouse-side-button:$button';
|
|
_capturedClass = rust.BridgePttInputClass.mouseSideButton;
|
|
});
|
|
}
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
final l10n = AppL10n.of(context);
|
|
final theme = Theme.of(context);
|
|
return AlertDialog(
|
|
title: Text(l10n.pttConfigureTitle),
|
|
content: SizedBox(
|
|
width: 360,
|
|
child: Focus(
|
|
focusNode: _focusNode,
|
|
onKeyEvent: _onKeyEvent,
|
|
autofocus: true,
|
|
child: Listener(
|
|
// HitTestBehavior.opaque so the Listener fires for
|
|
// mouse side-button presses anywhere inside the
|
|
// dialog's bounds, not just on top of a child widget.
|
|
// Default (deferToChild) only delivers events when a
|
|
// child's hit-test claims them; the surrounding padding
|
|
// and Container backgrounds don't, so the user had to
|
|
// hover over the captured-result Container before the
|
|
// side-button click would register. Opaque means the
|
|
// entire dialog content area receives PointerDown
|
|
// events.
|
|
behavior: HitTestBehavior.opaque,
|
|
// Capture mouse side buttons (4 and 5) without
|
|
// capturing primary / secondary clicks which the
|
|
// user uses to interact with the dialog itself. The
|
|
// raw button bitmask values are stable per Flutter's
|
|
// `PointerEvent.buttons` documentation (back = 0x08,
|
|
// forward = 0x10).
|
|
onPointerDown: (e) {
|
|
const int back = 0x08;
|
|
const int forward = 0x10;
|
|
if (e.buttons == back || e.buttons == forward) {
|
|
_captureMouseSideButton(e.buttons);
|
|
}
|
|
},
|
|
child: Column(
|
|
mainAxisSize: MainAxisSize.min,
|
|
crossAxisAlignment: CrossAxisAlignment.start,
|
|
children: [
|
|
Text(
|
|
l10n.pttConfigurePrompt,
|
|
style: theme.textTheme.bodyMedium,
|
|
),
|
|
const SizedBox(height: 12),
|
|
Container(
|
|
padding: const EdgeInsets.symmetric(
|
|
vertical: 12,
|
|
horizontal: 16,
|
|
),
|
|
decoration: BoxDecoration(
|
|
color: theme.colorScheme.surfaceContainerHighest,
|
|
borderRadius: BorderRadius.circular(6),
|
|
),
|
|
child: Text(
|
|
_captured == null
|
|
? l10n.pttConfigureWaiting
|
|
: '${l10n.pttConfigureCaptured}: $_captured',
|
|
style: theme.textTheme.bodyMedium?.copyWith(
|
|
fontFamily: 'monospace',
|
|
),
|
|
),
|
|
),
|
|
const SizedBox(height: 12),
|
|
Text(
|
|
l10n.pttConfigurePrivacyNote,
|
|
style: theme.textTheme.bodySmall?.copyWith(
|
|
color: theme.colorScheme.onSurfaceVariant,
|
|
),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
),
|
|
),
|
|
actions: [
|
|
TextButton(
|
|
onPressed: () => Navigator.of(context).pop(),
|
|
child: Text(l10n.closeAction),
|
|
),
|
|
FilledButton(
|
|
onPressed: _captured == null
|
|
? null
|
|
: () => Navigator.of(context).pop(
|
|
_CapturedBinding(
|
|
inputClass: _capturedClass,
|
|
platformKey: _captured!,
|
|
),
|
|
),
|
|
child: Text(l10n.pttConfigureSaveAction),
|
|
),
|
|
],
|
|
);
|
|
}
|
|
}
|