From 32fc942a043ab45aa763ceb040ef0c61eb501705 Mon Sep 17 00:00:00 2001 From: zarzet <42882290+zarzet@users.noreply.github.com> Date: Sun, 25 Oct 2026 02:37:07 +0700 Subject: [PATCH] feat(link): add the phone client for desktop discovery and pairing Phones find Mornye on a computer over mDNS (bonsoir, _mornye._tcp), pair with its 6-digit PIN and keep a live session with the chosen desktop. - Pinned HTTPS: first contact records the presented certificate and checks it against info and the mDNS fingerprint; later requests and the WebSocket accept only that SHA-256. - Pairing posts the PIN proof, maps bad_proof, pairing_closed and 429 to clear errors, saves a Subsonic API-key network connection, adds it to Library and scans it. Re-pairing replaces the key in place. - LinkClientSession: Bearer JSON get/post with timeouts and LinkException mapping, WebSocket hello/welcome, backoff from 1 s doubling to 30 s, pause in the background, reconnect when discovery sees the desktop again, address updates when it moves. - LinkClientController publishes the active session through linkActiveClientProvider and rescans on catalog.changed. - Settings entry "Mornye on your computer" on Android and iOS with nearby and paired computers, PIN and manual address dialogs, forget, and local network permission, Wi-Fi and certificate warnings. - iOS NSBonjourServices and the Android multicast permission. --- android/app/src/main/AndroidManifest.xml | 2 + ios/Runner/Info.plist | 4 + lib/l10n/arb/app_en.arb | 231 +++++++ lib/l10n/arb/app_id.arb | 51 +- .../settings/link_pairing_dialogs.dart | 404 ++++++++++++ lib/screens/settings/link_settings_page.dart | 417 ++++++++++++ lib/screens/settings/settings_tab.dart | 18 + .../link/client/link_client_bonsoir.dart | 66 ++ .../link/client/link_client_controller.dart | 620 ++++++++++++++++++ .../link/client/link_client_discovery.dart | 262 ++++++++ .../link/client/link_client_http.dart | 205 ++++++ .../link/client/link_client_library.dart | 149 +++++ .../link/client/link_client_pairing.dart | 276 ++++++++ .../link/client/link_client_session.dart | 470 +++++++++++++ .../link/client/link_client_store.dart | 125 ++++ macos/Flutter/GeneratedPluginRegistrant.swift | 2 + pubspec.lock | 48 ++ pubspec.yaml | 2 + test/link_client_controller_test.dart | 364 ++++++++++ test/link_client_discovery_test.dart | 188 ++++++ test/link_client_pairing_test.dart | 354 ++++++++++ test/link_client_session_test.dart | 564 ++++++++++++++++ test/link_client_store_test.dart | 95 +++ test/link_settings_page_test.dart | 339 ++++++++++ test/support/link_client_fakes.dart | 266 ++++++++ .../flutter/generated_plugin_registrant.cc | 3 + windows/flutter/generated_plugins.cmake | 1 + 27 files changed, 5525 insertions(+), 1 deletion(-) create mode 100644 lib/screens/settings/link_pairing_dialogs.dart create mode 100644 lib/screens/settings/link_settings_page.dart create mode 100644 lib/services/link/client/link_client_bonsoir.dart create mode 100644 lib/services/link/client/link_client_controller.dart create mode 100644 lib/services/link/client/link_client_discovery.dart create mode 100644 lib/services/link/client/link_client_http.dart create mode 100644 lib/services/link/client/link_client_library.dart create mode 100644 lib/services/link/client/link_client_pairing.dart create mode 100644 lib/services/link/client/link_client_session.dart create mode 100644 lib/services/link/client/link_client_store.dart create mode 100644 test/link_client_controller_test.dart create mode 100644 test/link_client_discovery_test.dart create mode 100644 test/link_client_pairing_test.dart create mode 100644 test/link_client_session_test.dart create mode 100644 test/link_client_store_test.dart create mode 100644 test/link_settings_page_test.dart create mode 100644 test/support/link_client_fakes.dart diff --git a/android/app/src/main/AndroidManifest.xml b/android/app/src/main/AndroidManifest.xml index 8048f0d66..dd9d33df4 100644 --- a/android/app/src/main/AndroidManifest.xml +++ b/android/app/src/main/AndroidManifest.xml @@ -13,6 +13,8 @@ + + NSLocalNetworkUsageDescription Connect to your music servers and network storage to browse and play your music. + NSBonjourServices + + _mornye._tcp + NSAppTransportSecurity NSAllowsArbitraryLoads diff --git a/lib/l10n/arb/app_en.arb b/lib/l10n/arb/app_en.arb index 43638fd1b..a90b5eaf4 100644 --- a/lib/l10n/arb/app_en.arb +++ b/lib/l10n/arb/app_en.arb @@ -7835,5 +7835,236 @@ "desktopShortcutToggleSidebar": "Show or hide sidebar", "@desktopShortcutToggleSidebar": { "description": "Keyboard Shortcuts row for the shortcut that collapses or expands the desktop sidebar" + }, + "linkSettingsTitle": "Mornye on your computer", + "@linkSettingsTitle": { + "description": "Phone Settings entry that pairs the phone with the Mornye desktop app on the local network" + }, + "linkSettingsSubtitle": "Play and control your computer's library", + "@linkSettingsSubtitle": { + "description": "Subtitle of the Mornye on your computer entry in phone Settings" + }, + "linkPageTitle": "Computers", + "@linkPageTitle": { + "description": "Title of the page listing computers running Mornye that the phone can pair with; kept short for the large title" + }, + "linkPageDescription": "Pair with Mornye on your computer to play its library on this phone and control what it plays. Both devices need to be on the same network.", + "@linkPageDescription": { + "description": "Introduction at the top of the computers page" + }, + "linkPairedSection": "Paired computers", + "@linkPairedSection": { + "description": "Section header for computers this phone is paired with" + }, + "linkNearbySection": "On this network", + "@linkNearbySection": { + "description": "Section header for computers running Mornye found on the local network" + }, + "linkSearching": "Looking for computers...", + "@linkSearching": { + "description": "Row shown while the phone searches the local network for computers" + }, + "linkNoneFoundTitle": "No computers found", + "@linkNoneFoundTitle": { + "description": "Row shown when the phone is not searching and found no computer" + }, + "linkNoneFound": "Open Mornye on your computer and turn on Share with Mornye on your phone in its settings.", + "@linkNoneFound": { + "description": "Hint under the search row when no computer was found yet; Share with Mornye on your phone is the name of the desktop setting" + }, + "linkAddManually": "Add by address", + "@linkAddManually": { + "description": "Button and dialog title for pairing with a computer by typing its address and port" + }, + "linkManualHost": "Computer address", + "@linkManualHost": { + "description": "Field label for the computer's IP address or host name" + }, + "linkManualPort": "Port", + "@linkManualPort": { + "description": "Field label for the network port of the Mornye desktop server" + }, + "linkManualMessage": "Mornye on your computer shows its address and port where you turn on sharing.", + "@linkManualMessage": { + "description": "Explains where to find the address and port to type" + }, + "linkContinue": "Continue", + "@linkContinue": { + "description": "Dialog action that continues to the PIN step after typing an address" + }, + "linkStateConnected": "Connected", + "@linkStateConnected": { + "description": "Status of the paired computer that is connected" + }, + "linkStateConnecting": "Connecting...", + "@linkStateConnecting": { + "description": "Status of the paired computer while the phone connects to it" + }, + "linkStateDisconnected": "Not connected", + "@linkStateDisconnected": { + "description": "Status of the paired computer when it cannot be reached" + }, + "linkStateInactive": "Tap to use this computer", + "@linkStateInactive": { + "description": "Status of a paired computer other than the one in use; tapping it makes it the one in use" + }, + "linkActive": "In use", + "@linkActive": { + "description": "Label next to the paired computer the phone currently uses, shown when several are paired" + }, + "linkForget": "Forget", + "@linkForget": { + "description": "Action that unpairs a computer from this phone" + }, + "linkForgetTitle": "Forget {name}?", + "@linkForgetTitle": { + "description": "Title of the dialog confirming that a paired computer is forgotten", + "placeholders": { + "name": { + "type": "String" + } + } + }, + "linkForgetMessage": "This phone stops connecting to it. You can pair again later.", + "@linkForgetMessage": { + "description": "Explanation in the forget computer dialog" + }, + "linkForgetRemoveLibrary": "Also remove its music from Library", + "@linkForgetRemoveLibrary": { + "description": "Switch in the forget computer dialog that also removes the computer's network connection and Library source" + }, + "linkPinTitle": "Pair with {name}", + "@linkPinTitle": { + "description": "Title of the dialog asking for the pairing PIN", + "placeholders": { + "name": { + "type": "String" + } + } + }, + "linkPinMessage": "Enter the 6-digit PIN shown on your computer.", + "@linkPinMessage": { + "description": "Instruction in the pairing PIN dialog" + }, + "linkPinField": "PIN", + "@linkPinField": { + "description": "Label of the pairing PIN field" + }, + "linkPinCode": "Your computer shows the code {code} next to the PIN. Pair only if it matches.", + "@linkPinCode": { + "description": "Security check in the PIN dialog; the placeholder is 8 hexadecimal characters of the computer's certificate fingerprint", + "placeholders": { + "code": { + "type": "String" + } + } + }, + "linkPinNotOpen": "Pairing is not open yet. Start pairing in Mornye on your computer to show a PIN.", + "@linkPinNotOpen": { + "description": "Note in the PIN dialog when the computer reports that no pairing window is open" + }, + "linkPair": "Pair", + "@linkPair": { + "description": "Action that sends the PIN to pair with the computer" + }, + "linkPaired": "Paired with {name}. Its music is being added to Library.", + "@linkPaired": { + "description": "Message after pairing succeeded", + "placeholders": { + "name": { + "type": "String" + } + } + }, + "linkPairAgain": "Pair again", + "@linkPairAgain": { + "description": "Action that repeats pairing with a computer that no longer accepts this phone" + }, + "linkErrorBadPin": "That PIN is not right. Check the PIN on your computer and try again.", + "@linkErrorBadPin": { + "description": "Pairing error when the PIN is wrong" + }, + "linkErrorPairingClosed": "Pairing is not open on your computer. Start pairing there, then try again.", + "@linkErrorPairingClosed": { + "description": "Pairing error when the computer has no pairing window open" + }, + "linkErrorTooManyAttempts": "Too many attempts. Wait a moment, then try again.", + "@linkErrorTooManyAttempts": { + "description": "Pairing error when the computer rate limits pairing attempts" + }, + "linkErrorCertificateTitle": "Computer not verified", + "@linkErrorCertificateTitle": { + "description": "Title of the warning shown when the computer's certificate does not match what it reported" + }, + "linkErrorCertificate": "The computer's security certificate does not match what it reported. Someone on this network may be intercepting the connection, so pairing stopped.", + "@linkErrorCertificate": { + "description": "Warning shown when the certificate seen during the connection differs from the computer's reported fingerprint" + }, + "linkErrorIncompatible": "This computer runs a Mornye version that cannot pair with this phone. Update Mornye on both devices.", + "@linkErrorIncompatible": { + "description": "Pairing error when the computer is not a compatible Mornye desktop" + }, + "linkErrorUnreachable": "The computer could not be reached. Check that Mornye is open on it and that both devices are on the same network.", + "@linkErrorUnreachable": { + "description": "Pairing error when the computer cannot be reached" + }, + "linkErrorTimeout": "The computer did not answer in time. Try again.", + "@linkErrorTimeout": { + "description": "Pairing error when the computer does not answer" + }, + "linkErrorInvalidAddress": "Enter a valid address and port, such as 192.168.1.20 and 47710.", + "@linkErrorInvalidAddress": { + "description": "Error for an address or port that cannot be used" + }, + "linkErrorFailed": "Pairing failed. Try again.", + "@linkErrorFailed": { + "description": "Generic pairing error" + }, + "linkLocalNetworkTitle": "Local network access needed", + "@linkLocalNetworkTitle": { + "description": "Title of the notice shown when the phone is not allowed to use the local network" + }, + "linkLocalNetworkMessage": "Mornye needs local network access to find your computer and connect to it.", + "@linkLocalNetworkMessage": { + "description": "Explains why local network access is needed" + }, + "linkLocalNetworkAllow": "Allow access", + "@linkLocalNetworkAllow": { + "description": "Button that asks for local network access again" + }, + "linkWifiOffTitle": "Not on Wi-Fi", + "@linkWifiOffTitle": { + "description": "Title of the notice shown when the phone is not connected to Wi-Fi or Ethernet" + }, + "linkWifiOffMessage": "Connect this phone to the same Wi-Fi network as your computer.", + "@linkWifiOffMessage": { + "description": "Explains that the phone must join the computer's Wi-Fi network" + }, + "linkIssueUnauthorized": "{name} no longer accepts this phone. Pair again to reconnect.", + "@linkIssueUnauthorized": { + "description": "Notice when the paired computer refuses the phone's key", + "placeholders": { + "name": { + "type": "String" + } + } + }, + "linkIssueCertificate": "{name} presented a different security certificate. Pair again only if you reinstalled or reset Mornye on that computer.", + "@linkIssueCertificate": { + "description": "Warning when a paired computer's certificate changed", + "placeholders": { + "name": { + "type": "String" + } + } + }, + "linkIssueIncompatible": "Update Mornye on this phone and on {name} to connect.", + "@linkIssueIncompatible": { + "description": "Notice when the paired computer speaks another protocol version", + "placeholders": { + "name": { + "type": "String" + } + } } } diff --git a/lib/l10n/arb/app_id.arb b/lib/l10n/arb/app_id.arb index 98381d41e..6bd876c27 100644 --- a/lib/l10n/arb/app_id.arb +++ b/lib/l10n/arb/app_id.arb @@ -7391,5 +7391,54 @@ "settingsKeyboardShortcutsSubtitle": "Tombol untuk pemutaran, navigasi dan panel", "desktopShortcutsNavigation": "Navigasi", "desktopShortcutDismiss": "Tutup dialog atau halaman", - "desktopShortcutToggleSidebar": "Tampilkan atau sembunyikan sidebar" + "desktopShortcutToggleSidebar": "Tampilkan atau sembunyikan sidebar", + "linkSettingsTitle": "Mornye di komputer Anda", + "linkSettingsSubtitle": "Putar dan kendalikan pustaka komputer Anda", + "linkPageTitle": "Komputer", + "linkPageDescription": "Pasangkan dengan Mornye di komputer Anda untuk memutar pustakanya di ponsel ini dan mengendalikan yang diputarnya. Kedua perangkat harus berada di jaringan yang sama.", + "linkPairedSection": "Komputer terpasang", + "linkNearbySection": "Di jaringan ini", + "linkSearching": "Mencari komputer...", + "linkNoneFoundTitle": "Tidak ada komputer ditemukan", + "linkNoneFound": "Buka Mornye di komputer Anda dan aktifkan Bagikan dengan Mornye di ponsel Anda di pengaturannya.", + "linkAddManually": "Tambah lewat alamat", + "linkManualHost": "Alamat komputer", + "linkManualPort": "Port", + "linkManualMessage": "Mornye di komputer Anda menampilkan alamat dan port di tempat Anda mengaktifkan berbagi.", + "linkContinue": "Lanjutkan", + "linkStateConnected": "Terhubung", + "linkStateConnecting": "Menghubungkan...", + "linkStateDisconnected": "Tidak terhubung", + "linkStateInactive": "Ketuk untuk memakai komputer ini", + "linkActive": "Dipakai", + "linkForget": "Lupakan", + "linkForgetTitle": "Lupakan {name}?", + "linkForgetMessage": "Ponsel ini berhenti terhubung ke komputer tersebut. Anda dapat memasangkannya lagi nanti.", + "linkForgetRemoveLibrary": "Hapus juga musiknya dari Pustaka", + "linkPinTitle": "Pasangkan dengan {name}", + "linkPinMessage": "Masukkan PIN 6 digit yang tampil di komputer Anda.", + "linkPinField": "PIN", + "linkPinCode": "Komputer Anda menampilkan kode {code} di samping PIN. Pasangkan hanya jika kodenya sama.", + "linkPinNotOpen": "Pemasangan belum dibuka. Mulai pemasangan di Mornye pada komputer Anda untuk menampilkan PIN.", + "linkPair": "Pasangkan", + "linkPaired": "Terpasang dengan {name}. Musiknya sedang ditambahkan ke Pustaka.", + "linkPairAgain": "Pasangkan lagi", + "linkErrorBadPin": "PIN tersebut salah. Periksa PIN di komputer Anda dan coba lagi.", + "linkErrorPairingClosed": "Pemasangan tidak dibuka di komputer Anda. Mulai pemasangan di sana, lalu coba lagi.", + "linkErrorTooManyAttempts": "Terlalu banyak percobaan. Tunggu sebentar, lalu coba lagi.", + "linkErrorCertificateTitle": "Komputer tidak terverifikasi", + "linkErrorCertificate": "Sertifikat keamanan komputer tidak cocok dengan yang dilaporkannya. Seseorang di jaringan ini mungkin menyadap koneksi, jadi pemasangan dihentikan.", + "linkErrorIncompatible": "Komputer ini menjalankan versi Mornye yang tidak dapat dipasangkan dengan ponsel ini. Perbarui Mornye di kedua perangkat.", + "linkErrorUnreachable": "Komputer tidak dapat dijangkau. Pastikan Mornye terbuka di komputer dan kedua perangkat berada di jaringan yang sama.", + "linkErrorTimeout": "Komputer tidak menjawab tepat waktu. Coba lagi.", + "linkErrorInvalidAddress": "Masukkan alamat dan port yang valid, misalnya 192.168.1.20 dan 47710.", + "linkErrorFailed": "Pemasangan gagal. Coba lagi.", + "linkLocalNetworkTitle": "Perlu akses jaringan lokal", + "linkLocalNetworkMessage": "Mornye memerlukan akses jaringan lokal untuk menemukan komputer Anda dan terhubung ke sana.", + "linkLocalNetworkAllow": "Izinkan akses", + "linkWifiOffTitle": "Tidak terhubung ke Wi-Fi", + "linkWifiOffMessage": "Hubungkan ponsel ini ke jaringan Wi-Fi yang sama dengan komputer Anda.", + "linkIssueUnauthorized": "{name} tidak lagi menerima ponsel ini. Pasangkan lagi untuk terhubung kembali.", + "linkIssueCertificate": "{name} menampilkan sertifikat keamanan yang berbeda. Pasangkan lagi hanya jika Anda memasang ulang atau mengatur ulang Mornye di komputer tersebut.", + "linkIssueIncompatible": "Perbarui Mornye di ponsel ini dan di {name} untuk terhubung." } diff --git a/lib/screens/settings/link_pairing_dialogs.dart b/lib/screens/settings/link_pairing_dialogs.dart new file mode 100644 index 000000000..209dd6fcd --- /dev/null +++ b/lib/screens/settings/link_pairing_dialogs.dart @@ -0,0 +1,404 @@ +import 'dart:io'; + +import 'package:flutter/cupertino.dart'; +import 'package:flutter/material.dart'; +import 'package:flutter/services.dart'; +import 'package:mornye/l10n/l10n.dart'; +import 'package:mornye/services/link/client/link_client_pairing.dart'; +import 'package:mornye/services/link/link_protocol.dart'; +import 'package:mornye/theme/mornye_theme.dart'; +import 'package:mornye/widgets/app_alert_dialog.dart'; +import 'package:mornye/widgets/app_progress_indicator.dart'; +import 'package:mornye/widgets/app_switch.dart'; +import 'package:mornye/widgets/app_text_field.dart'; + +/// The message for a pairing failure. +String linkPairingErrorMessage(AppLocalizations l10n, LinkPairingError error) => + switch (error) { + LinkPairingError.badPin => l10n.linkErrorBadPin, + LinkPairingError.pairingClosed => l10n.linkErrorPairingClosed, + LinkPairingError.tooManyAttempts => l10n.linkErrorTooManyAttempts, + LinkPairingError.certificateMismatch => l10n.linkErrorCertificate, + LinkPairingError.incompatible => l10n.linkErrorIncompatible, + LinkPairingError.invalidAddress => l10n.linkErrorInvalidAddress, + LinkPairingError.localNetworkPermission => + l10n.networkErrorLocalPermission, + LinkPairingError.unreachable => l10n.linkErrorUnreachable, + LinkPairingError.timeout => l10n.linkErrorTimeout, + LinkPairingError.failed => l10n.linkErrorFailed, + }; + +/// Host and port from what someone typed: `192.168.1.20`, `host:47710`, +/// `https://[fe80::2]:47710/` and the like. [portInput] is used when the +/// address carries no port. Null when either part is unusable. +({String host, int port})? linkParseManualAddress( + String hostInput, + String portInput, +) { + var text = hostInput.trim().replaceFirst( + RegExp(r'^[a-z]+://', caseSensitive: false), + '', + ); + final slash = text.indexOf('/'); + if (slash >= 0) text = text.substring(0, slash); + String host; + String? port; + final bracketed = RegExp(r'^\[([^\]]+)\](?::(\d+))?$').firstMatch(text); + if (bracketed != null) { + host = bracketed[1]!; + port = bracketed[2]; + } else if (RegExp(r'^[^:]+:\d+$').hasMatch(text)) { + final colon = text.lastIndexOf(':'); + host = text.substring(0, colon); + port = text.substring(colon + 1); + } else { + host = text; + } + host = host.trim(); + final parsedPort = int.tryParse((port ?? portInput).trim()); + if (host.isEmpty || + parsedPort == null || + parsedPort < 1 || + parsedPort > 65535 || + host.contains(RegExp(r'[\s@/?#]')) || + (host.contains(':') && InternetAddress.tryParse(host) == null)) { + return null; + } + return (host: host, port: parsedPort); +} + +/// Asks for the desktop's PIN and pairs. [onSubmit] answers null on success, +/// which pops `true`, or the error to show while the dialog stays open. +class LinkPinDialog extends StatefulWidget { + const LinkPinDialog({ + super.key, + required this.serverName, + required this.shortFingerprint, + required this.pairingOpen, + required this.onSubmit, + }); + + static const fieldKey = ValueKey('link-pin-field'); + + final String serverName; + + /// The fingerprint's first 8 hex characters, shown on the desktop too. + final String shortFingerprint; + + /// Whether the desktop reported an open pairing window. + final bool pairingOpen; + final Future Function(String pin) onSubmit; + + @override + State createState() => _LinkPinDialogState(); +} + +class _LinkPinDialogState extends State { + final _pin = TextEditingController(); + var _busy = false; + LinkPairingError? _error; + + bool get _complete => RegExp(r'^\d{6}$').hasMatch(_pin.text); + + @override + void dispose() { + _pin.dispose(); + super.dispose(); + } + + Future _submit() async { + if (!_complete || _busy) return; + setState(() { + _busy = true; + _error = null; + }); + final error = await widget.onSubmit(_pin.text); + if (!mounted) return; + if (error == null) { + Navigator.of(context).pop(true); + return; + } + setState(() { + _busy = false; + _error = error; + if (error == LinkPairingError.badPin) _pin.clear(); + }); + } + + @override + Widget build(BuildContext context) { + final l10n = context.l10n; + final theme = Theme.of(context); + final formatters = [ + FilteringTextInputFormatter.digitsOnly, + LengthLimitingTextInputFormatter(6), + ]; + final pinStyle = theme.textTheme.headlineSmall?.copyWith( + letterSpacing: 8, + fontFeatures: const [FontFeature.tabularFigures()], + ); + final field = context.isMornye + ? CupertinoTextField( + key: LinkPinDialog.fieldKey, + controller: _pin, + enabled: !_busy, + autofocus: true, + placeholder: l10n.linkPinField, + keyboardType: TextInputType.number, + inputFormatters: formatters, + autofillHints: const [AutofillHints.oneTimeCode], + textAlign: TextAlign.center, + style: pinStyle, + padding: const EdgeInsets.all(12), + onChanged: (_) => setState(() {}), + onSubmitted: (_) => _submit(), + ) + : Semantics( + label: l10n.linkPinField, + child: TextField( + key: LinkPinDialog.fieldKey, + controller: _pin, + enabled: !_busy, + autofocus: true, + keyboardType: TextInputType.number, + inputFormatters: formatters, + autofillHints: const [AutofillHints.oneTimeCode], + textAlign: TextAlign.center, + style: pinStyle, + decoration: InputDecoration( + labelText: l10n.linkPinField, + border: const OutlineInputBorder(), + ), + onChanged: (_) => setState(() {}), + onSubmitted: (_) => _submit(), + ), + ); + final note = theme.textTheme.bodySmall?.copyWith( + color: theme.colorScheme.onSurfaceVariant, + ); + return AppAlertDialog( + title: Text(l10n.linkPinTitle(widget.serverName)), + content: Column( + mainAxisSize: MainAxisSize.min, + crossAxisAlignment: CrossAxisAlignment.stretch, + children: [ + Text(l10n.linkPinMessage), + const SizedBox(height: 16), + field, + const SizedBox(height: 12), + Text(l10n.linkPinCode(widget.shortFingerprint), style: note), + if (!widget.pairingOpen) ...[ + const SizedBox(height: 8), + Text(l10n.linkPinNotOpen, style: note), + ], + if (_error case final error?) ...[ + const SizedBox(height: 12), + Text( + linkPairingErrorMessage(l10n, error), + style: theme.textTheme.bodyMedium?.copyWith( + color: theme.colorScheme.error, + ), + ), + ], + if (_busy) ...[ + const SizedBox(height: 12), + const AppProgressIndicator.linear(), + ], + ], + ), + actions: [ + AppDialogAction( + onPressed: _busy ? null : () => Navigator.of(context).pop(false), + child: Text(l10n.dialogCancel), + ), + AppDialogAction( + filled: true, + onPressed: _busy || !_complete ? null : _submit, + child: Text(l10n.linkPair), + ), + ], + ); + } +} + +/// Asks for a desktop's address and port, for networks without mDNS and +/// emulators. Pops the parsed address, or null when cancelled. +class LinkManualAddDialog extends StatefulWidget { + const LinkManualAddDialog({super.key}); + + static const hostKey = ValueKey('link-manual-host'); + static const portKey = ValueKey('link-manual-port'); + + @override + State createState() => _LinkManualAddDialogState(); +} + +class _LinkManualAddDialogState extends State { + final _host = TextEditingController(); + final _port = TextEditingController(text: '$linkPortFirst'); + var _invalid = false; + + @override + void dispose() { + _host.dispose(); + _port.dispose(); + super.dispose(); + } + + void _submit() { + final address = linkParseManualAddress(_host.text, _port.text); + if (address == null) { + setState(() => _invalid = true); + return; + } + Navigator.of(context).pop(address); + } + + Widget _field( + Key key, + TextEditingController controller, + String label, { + required TextInputType keyboardType, + String? hint, + bool last = false, + }) { + if (context.isMornye) { + return CupertinoTextField( + key: key, + controller: controller, + placeholder: hint ?? label, + keyboardType: keyboardType, + autocorrect: false, + enableSuggestions: false, + padding: const EdgeInsets.all(12), + textInputAction: last ? TextInputAction.done : TextInputAction.next, + onSubmitted: last ? (_) => _submit() : null, + ); + } + return AppTextField( + key: key, + controller: controller, + label: label, + hint: hint, + keyboardType: keyboardType, + autocorrect: false, + outlined: true, + textInputAction: last ? TextInputAction.done : TextInputAction.next, + onSubmitted: last ? (_) => _submit() : null, + decoration: InputDecoration( + labelText: label, + hintText: hint, + border: const OutlineInputBorder(), + ), + ); + } + + @override + Widget build(BuildContext context) { + final l10n = context.l10n; + final theme = Theme.of(context); + return AppAlertDialog( + title: Text(l10n.linkAddManually), + content: Column( + mainAxisSize: MainAxisSize.min, + crossAxisAlignment: CrossAxisAlignment.stretch, + children: [ + Text(l10n.linkManualMessage), + const SizedBox(height: 16), + _field( + LinkManualAddDialog.hostKey, + _host, + l10n.linkManualHost, + hint: '192.168.1.20', + keyboardType: TextInputType.url, + ), + const SizedBox(height: 12), + _field( + LinkManualAddDialog.portKey, + _port, + l10n.linkManualPort, + keyboardType: TextInputType.number, + last: true, + ), + if (_invalid) ...[ + const SizedBox(height: 12), + Text( + l10n.linkErrorInvalidAddress, + style: theme.textTheme.bodyMedium?.copyWith( + color: theme.colorScheme.error, + ), + ), + ], + ], + ), + actions: [ + AppDialogAction( + onPressed: () => Navigator.of(context).pop(), + child: Text(l10n.dialogCancel), + ), + AppDialogAction( + filled: true, + onPressed: _submit, + child: Text(l10n.linkContinue), + ), + ], + ); + } +} + +/// Confirms forgetting [name]. Pops whether its music should leave Library +/// too, or null when cancelled. +class LinkForgetDialog extends StatefulWidget { + const LinkForgetDialog({super.key, required this.name}); + + final String name; + + @override + State createState() => _LinkForgetDialogState(); +} + +class _LinkForgetDialogState extends State { + var _removeLibrary = true; + + @override + Widget build(BuildContext context) { + final l10n = context.l10n; + final error = Theme.of(context).colorScheme.error; + return AppAlertDialog( + title: Text(l10n.linkForgetTitle(widget.name)), + content: Column( + mainAxisSize: MainAxisSize.min, + crossAxisAlignment: CrossAxisAlignment.stretch, + children: [ + Text(l10n.linkForgetMessage), + const SizedBox(height: 12), + MergeSemantics( + child: Row( + children: [ + Expanded(child: Text(l10n.linkForgetRemoveLibrary)), + const SizedBox(width: 12), + AppSwitch( + value: _removeLibrary, + semanticLabel: l10n.linkForgetRemoveLibrary, + onChanged: (value) => setState(() => _removeLibrary = value), + ), + ], + ), + ), + ], + ), + actions: [ + AppDialogAction( + onPressed: () => Navigator.of(context).pop(), + child: Text(l10n.dialogCancel), + ), + AppDialogAction( + isDestructive: true, + style: TextButton.styleFrom(foregroundColor: error), + onPressed: () => Navigator.of(context).pop(_removeLibrary), + child: Text(l10n.linkForget), + ), + ], + ); + } +} diff --git a/lib/screens/settings/link_settings_page.dart b/lib/screens/settings/link_settings_page.dart new file mode 100644 index 000000000..2a3f3a386 --- /dev/null +++ b/lib/screens/settings/link_settings_page.dart @@ -0,0 +1,417 @@ +import 'package:flutter/cupertino.dart'; +import 'package:flutter/material.dart'; +import 'package:flutter_riverpod/flutter_riverpod.dart'; +import 'package:mornye/l10n/l10n.dart'; +import 'package:mornye/screens/settings/link_pairing_dialogs.dart'; +import 'package:mornye/services/link/client/link_client_controller.dart'; +import 'package:mornye/services/link/client/link_client_discovery.dart'; +import 'package:mornye/services/link/client/link_client_pairing.dart'; +import 'package:mornye/services/link/client/link_client_session.dart'; +import 'package:mornye/services/link/link_client_api.dart'; +import 'package:mornye/services/local_network_access.dart'; +import 'package:mornye/theme/mornye_theme.dart'; +import 'package:mornye/utils/nav_bar_inset.dart'; +import 'package:mornye/widgets/app_action_button.dart'; +import 'package:mornye/widgets/app_alert_dialog.dart'; +import 'package:mornye/widgets/app_progress_indicator.dart'; +import 'package:mornye/widgets/app_sliver_header.dart'; +import 'package:mornye/widgets/expressive_icon_button.dart'; +import 'package:mornye/widgets/settings_group.dart'; + +/// Mornye on your computer: paired computers with their connection, the +/// computers found on the network, and pairing. +class LinkSettingsPage extends ConsumerStatefulWidget { + const LinkSettingsPage({super.key}); + + @override + ConsumerState createState() => _LinkSettingsPageState(); +} + +class _LinkSettingsPageState extends ConsumerState { + late final VoidCallback _releaseDiscovery; + var _busy = false; + + LinkClientController get _controller => + ref.read(linkClientControllerProvider.notifier); + + @override + void initState() { + super.initState(); + _releaseDiscovery = _controller.acquireDiscovery(); + } + + @override + void dispose() { + _releaseDiscovery(); + super.dispose(); + } + + void _showMessage(String message) { + if (!mounted) return; + ScaffoldMessenger.of( + context, + ).showSnackBar(SnackBar(content: Text(message))); + } + + Future _showCertificateWarning() => showAppDialog( + context: context, + builder: (context) => AppAlertDialog( + icon: const Icon(Icons.gpp_maybe_outlined), + title: Text(context.l10n.linkErrorCertificateTitle), + content: Text(context.l10n.linkErrorCertificate), + actions: [ + AppDialogAction( + filled: true, + onPressed: () => Navigator.of(context).pop(), + child: Text(MaterialLocalizations.of(context).okButtonLabel), + ), + ], + ), + ); + + /// Reads the computer's `info`, then asks for the PIN and pairs. + Future _pair( + String host, + int port, { + String? expectedFingerprint, + String? name, + }) async { + if (_busy) return; + setState(() => _busy = true); + final LinkPairingTarget target; + try { + target = await _controller.probe( + host, + port, + expectedFingerprint: expectedFingerprint, + ); + } on LinkPairingException catch (error) { + if (!mounted) return; + setState(() => _busy = false); + if (error.error == LinkPairingError.certificateMismatch) { + await _showCertificateWarning(); + } else { + _showMessage(linkPairingErrorMessage(context.l10n, error.error)); + } + return; + } + if (!mounted) return; + setState(() => _busy = false); + final serverName = target.info.name.isNotEmpty + ? target.info.name + : name ?? host; + final paired = await showAppDialog( + context: context, + barrierDismissible: false, + builder: (_) => LinkPinDialog( + serverName: serverName, + shortFingerprint: target.shortFingerprint, + pairingOpen: target.info.pairing, + onSubmit: (pin) async { + try { + await _controller.pair(target, pin); + return null; + } on LinkPairingException catch (error) { + return error.error; + } + }, + ), + ); + if (paired == true && mounted) { + _showMessage(context.l10n.linkPaired(serverName)); + } + } + + Future _pairDiscovered(LinkDiscoveredServer server) => _pair( + server.host, + server.port, + expectedFingerprint: server.fingerprint, + name: server.name, + ); + + /// Pairs a known computer again, at its advertised address when the + /// network shows it, else at the saved one. + Future _pairAgain(LinkServerRecord record) { + final found = ref + .read(linkClientControllerProvider) + .discoveredServer(record.serverId); + if (found != null) return _pairDiscovered(found); + final address = Uri.parse(record.address); + return _pair(address.host, address.port, name: record.name); + } + + Future _addManually() async { + final address = await showAppDialog<({String host, int port})>( + context: context, + builder: (_) => const LinkManualAddDialog(), + ); + if (address == null || !mounted) return; + await _pair(address.host, address.port); + } + + Future _forget(LinkServerRecord record) async { + final removeLibrary = await showAppDialog( + context: context, + builder: (_) => LinkForgetDialog(name: record.name), + ); + if (removeLibrary == null || !mounted) return; + await _controller.forget(record.serverId, removeLibrary: removeLibrary); + } + + Future _allowLocalNetwork() async { + try { + await _controller.requestLocalNetworkAccess(); + } on LocalNetworkPermissionException { + if (mounted) _showMessage(context.l10n.networkErrorLocalPermission); + } + } + + String _status(LinkClientState state, LinkServerRecord record) { + final l10n = context.l10n; + if (record.serverId != state.activeServerId) return l10n.linkStateInactive; + return switch (state.connection) { + LinkConnectionState.connected => l10n.linkStateConnected, + LinkConnectionState.connecting => l10n.linkStateConnecting, + LinkConnectionState.disconnected => l10n.linkStateDisconnected, + }; + } + + List _notices(LinkClientState state) { + final l10n = context.l10n; + final active = state.activeServer; + final permissionDenied = + state.discovery == LinkDiscoveryStatus.permissionDenied || + state.issue == LinkSessionIssue.localNetworkPermission; + return [ + if (permissionDenied) + SettingsInfoCard( + tone: SettingsInfoTone.warning, + icon: Icons.wifi_off_rounded, + title: l10n.linkLocalNetworkTitle, + message: l10n.linkLocalNetworkMessage, + action: AppActionButton( + onPressed: _allowLocalNetwork, + icon: const Icon(Icons.lock_open_outlined), + label: Text(l10n.linkLocalNetworkAllow), + tonal: true, + ), + ) + else if (!state.localNetworkAvailable) + SettingsInfoCard( + tone: SettingsInfoTone.warning, + icon: Icons.wifi_off_rounded, + title: l10n.linkWifiOffTitle, + message: l10n.linkWifiOffMessage, + ), + if (active != null && + state.connection != LinkConnectionState.connected && + (state.issue == LinkSessionIssue.certificate || + state.certificateChanged(active))) + SettingsInfoCard( + tone: SettingsInfoTone.error, + icon: Icons.gpp_maybe_outlined, + title: l10n.linkErrorCertificateTitle, + message: l10n.linkIssueCertificate(active.name), + action: AppActionButton( + onPressed: _busy ? null : () => _pairAgain(active), + icon: const Icon(Icons.link), + label: Text(l10n.linkPairAgain), + tonal: true, + ), + ) + else if (active != null && + state.connection != LinkConnectionState.connected && + state.issue == LinkSessionIssue.unauthorized) + SettingsInfoCard( + tone: SettingsInfoTone.error, + icon: Icons.link_off, + message: l10n.linkIssueUnauthorized(active.name), + action: AppActionButton( + onPressed: _busy ? null : () => _pairAgain(active), + icon: const Icon(Icons.link), + label: Text(l10n.linkPairAgain), + tonal: true, + ), + ) + else if (active != null && + state.connection != LinkConnectionState.connected && + state.issue == LinkSessionIssue.incompatible) + SettingsInfoCard( + tone: SettingsInfoTone.warning, + icon: Icons.system_update_outlined, + message: l10n.linkIssueIncompatible(active.name), + ), + ]; + } + + Widget _pairedRow(LinkClientState state, LinkServerRecord record) { + final l10n = context.l10n; + final active = record.serverId == state.activeServerId; + final scheme = Theme.of(context).colorScheme; + return SettingsItem( + icon: Icons.computer, + showIconInMornye: true, + iconColor: active && state.connection == LinkConnectionState.connected + ? scheme.primary + : null, + title: record.name, + titleTrailing: active && state.servers.length > 1 + ? Text( + l10n.linkActive, + style: Theme.of( + context, + ).textTheme.labelMedium?.copyWith(color: scheme.primary), + ) + : null, + subtitle: '${_status(state, record)} ยท ${Uri.parse(record.address).host}', + onTap: _busy + ? null + : active + ? (state.connection == LinkConnectionState.disconnected + ? _controller.retry + : null) + : () => _controller.setActive(record.serverId), + trailing: _LinkIconAction( + tooltip: l10n.linkForget, + icon: Icons.link_off, + cupertinoIcon: CupertinoIcons.minus_circle, + onPressed: _busy ? null : () => _forget(record), + ), + ); + } + + @override + Widget build(BuildContext context) { + final l10n = context.l10n; + final state = ref.watch(linkClientControllerProvider); + final unpaired = state.unpaired; + final searching = state.discovery == LinkDiscoveryStatus.searching; + final theme = Theme.of(context); + final note = theme.textTheme.bodyMedium?.copyWith( + color: theme.colorScheme.onSurfaceVariant, + ); + return Scaffold( + body: CustomScrollView( + slivers: [ + AppSliverHeader.page(title: l10n.linkPageTitle), + SliverToBoxAdapter( + child: _LinkInset( + child: Text(l10n.linkPageDescription, style: note), + ), + ), + if (_busy) + const SliverToBoxAdapter( + child: _LinkInset(child: AppProgressIndicator.linear()), + ), + SliverList.list(children: _notices(state)), + if (state.servers.isNotEmpty) + ...settingsSectionSlivers( + title: l10n.linkPairedSection, + children: [ + for (final record in state.servers) _pairedRow(state, record), + ], + ), + ...settingsSectionSlivers( + title: l10n.linkNearbySection, + children: [ + for (final server in unpaired) + SettingsItem( + icon: Icons.computer, + showIconInMornye: true, + title: server.name, + subtitle: server.host, + onTap: _busy ? null : () => _pairDiscovered(server), + ), + if (unpaired.isEmpty) + SettingsItem( + icon: Icons.wifi, + showIconInMornye: true, + title: searching + ? l10n.linkSearching + : l10n.linkNoneFoundTitle, + subtitle: l10n.linkNoneFound, + trailing: searching + ? SizedBox.square( + dimension: 24, + child: context.isMornye + ? const CupertinoActivityIndicator() + : const AppProgressIndicator.circular(), + ) + : null, + ), + ], + ), + SliverToBoxAdapter( + child: _LinkInset( + child: Align( + alignment: AlignmentDirectional.centerStart, + child: AppActionButton( + onPressed: _busy ? null : _addManually, + icon: const Icon(Icons.add), + label: Text(l10n.linkAddManually), + tonal: true, + ), + ), + ), + ), + const NavBarSliverSpacer(), + ], + ), + ); + } +} + +/// Lines free content up with the settings groups at any width. +class _LinkInset extends StatelessWidget { + const _LinkInset({required this.child}); + + final Widget child; + + @override + Widget build(BuildContext context) => LayoutBuilder( + builder: (context, constraints) { + final inset = settingsHorizontalInset(constraints.maxWidth); + return Padding( + padding: EdgeInsets.fromLTRB(inset + 8, 8, inset + 8, 8), + child: child, + ); + }, + ); +} + +class _LinkIconAction extends StatelessWidget { + const _LinkIconAction({ + required this.tooltip, + required this.icon, + required this.cupertinoIcon, + required this.onPressed, + }); + + final String tooltip; + final IconData icon; + final IconData cupertinoIcon; + final VoidCallback? onPressed; + + @override + Widget build(BuildContext context) => context.isMornye + ? Tooltip( + message: tooltip, + child: CupertinoButton( + onPressed: onPressed, + padding: const EdgeInsets.all(12), + child: Icon( + cupertinoIcon, + size: 24, + semanticLabel: tooltip, + color: onPressed == null + ? Theme.of(context).disabledColor + : Theme.of(context).colorScheme.primary, + ), + ), + ) + : ExpressiveIconButton( + icon: Icon(icon), + tooltip: tooltip, + onPressed: onPressed, + ); +} diff --git a/lib/screens/settings/settings_tab.dart b/lib/screens/settings/settings_tab.dart index 9faeeb0c9..f697b3ad5 100644 --- a/lib/screens/settings/settings_tab.dart +++ b/lib/screens/settings/settings_tab.dart @@ -19,6 +19,7 @@ import 'package:mornye/screens/settings/extensions_page.dart'; import 'package:mornye/screens/settings/files_settings_page.dart'; import 'package:mornye/screens/settings/keyboard_shortcuts_page.dart'; import 'package:mornye/screens/settings/library_settings_page.dart'; +import 'package:mornye/screens/settings/link_settings_page.dart'; import 'package:mornye/screens/network_storage_screen.dart'; import 'package:mornye/screens/settings/log_screen.dart'; import 'package:mornye/screens/settings/lyrics_settings_page.dart'; @@ -247,6 +248,23 @@ class _SettingsTabState extends ConsumerState { ], pageBuilder: () => const NetworkStorageScreen(), ), + if (Platform.isAndroid || Platform.isIOS) + _Destination( + icon: Icons.computer, + iconColor: Colors.deepPurple, + title: l10n.linkSettingsTitle, + subtitle: l10n.linkSettingsSubtitle, + keywords: const [ + 'computer', + 'desktop', + 'pc', + 'mac', + 'pair', + 'link', + 'komputer', + ], + pageBuilder: () => const LinkSettingsPage(), + ), _Destination( icon: Icons.sell_outlined, iconColor: Colors.amber, diff --git a/lib/services/link/client/link_client_bonsoir.dart b/lib/services/link/client/link_client_bonsoir.dart new file mode 100644 index 000000000..a4660de36 --- /dev/null +++ b/lib/services/link/client/link_client_bonsoir.dart @@ -0,0 +1,66 @@ +import 'dart:async'; + +import 'package:bonsoir/bonsoir.dart'; +import 'package:mornye/services/link/client/link_client_discovery.dart'; +import 'package:mornye/services/link/link_protocol.dart'; + +/// [LinkServiceBrowser] on Bonsoir (Android NSD, Apple Bonjour). Found +/// services are resolved right away, since the list shows their addresses. +class BonsoirLinkServiceBrowser implements LinkServiceBrowser { + BonsoirDiscovery? _discovery; + StreamSubscription? _subscription; + StreamController? _events; + + @override + Future> start() async { + await stop(); + final discovery = _discovery = BonsoirDiscovery( + type: linkServiceType, + printLogs: false, + ); + _events = StreamController(); + await discovery.initialize(); + _subscription = discovery.eventStream?.listen((event) { + switch (event) { + case BonsoirDiscoveryServiceFoundEvent(:final service): + unawaited( + service + .resolve(discovery.serviceResolver) + .catchError((Object _) {}), + ); + case BonsoirDiscoveryServiceResolvedEvent(:final service) || + BonsoirDiscoveryServiceUpdatedEvent(:final service): + _events?.add( + LinkServiceResolved( + name: service.name, + port: service.port, + addresses: service.hostAddresses, + hostname: service.hostname, + attributes: service.attributes, + ), + ); + case BonsoirDiscoveryServiceLostEvent(:final service): + _events?.add(LinkServiceLost(service.name)); + default: + break; + } + }, onError: (Object error) => _events?.addError(error)); + await discovery.start(); + return _events!.stream; + } + + @override + Future stop() async { + final discovery = _discovery; + _discovery = null; + final cancelling = _subscription?.cancel(); + _subscription = null; + // Nobody may listen any more, so the close is not awaited. + unawaited(_events?.close()); + _events = null; + await cancelling; + if (discovery != null && discovery.isReady && !discovery.isStopped) { + await discovery.stop(); + } + } +} diff --git a/lib/services/link/client/link_client_controller.dart b/lib/services/link/client/link_client_controller.dart new file mode 100644 index 000000000..70838c801 --- /dev/null +++ b/lib/services/link/client/link_client_controller.dart @@ -0,0 +1,620 @@ +import 'dart:async'; +import 'dart:io'; + +import 'package:connectivity_plus/connectivity_plus.dart'; +import 'package:device_info_plus/device_info_plus.dart'; +import 'package:flutter/widgets.dart'; +import 'package:flutter_riverpod/flutter_riverpod.dart'; +import 'package:mornye/constants/app_info.dart'; +import 'package:mornye/services/link/client/link_client_bonsoir.dart'; +import 'package:mornye/services/link/client/link_client_discovery.dart'; +import 'package:mornye/services/link/client/link_client_http.dart'; +import 'package:mornye/services/link/client/link_client_library.dart'; +import 'package:mornye/services/link/client/link_client_pairing.dart'; +import 'package:mornye/services/link/client/link_client_session.dart'; +import 'package:mornye/services/link/client/link_client_store.dart'; +import 'package:mornye/services/link/link_client_api.dart'; +import 'package:mornye/services/link/link_protocol.dart'; +import 'package:mornye/services/local_network_access.dart'; +import 'package:mornye/services/network_storage_service.dart'; +import 'package:mornye/utils/logger.dart'; + +final _log = AppLogger('LinkClient'); + +/// Whether this device runs the phone side of Mornye Link. +final linkClientSupportedProvider = Provider( + (ref) => Platform.isAndroid || Platform.isIOS, +); + +/// Device inputs of the client, replaced in tests. +class LinkClientEnvironment { + const LinkClientEnvironment({ + required this.deviceName, + required this.platform, + required this.appVersion, + required this.createBrowser, + required this.createSession, + required this.ensureLocalNetwork, + required this.onLocalNetwork, + }); + + /// The name desktops list this phone under. + final Future Function() deviceName; + + /// `android` or `ios`. + final String platform; + final String appVersion; + final LinkServiceBrowser Function() createBrowser; + final LinkSession Function( + LinkServerRecord server, + String apiKey, + LinkDeviceIdentity device, + ) + createSession; + + /// Asks for local network access where the OS gates it; throws + /// [LocalNetworkPermissionException] when refused. + final Future Function() ensureLocalNetwork; + + /// Whether Wi-Fi or Ethernet is connected. + final Future Function() onLocalNetwork; + + factory LinkClientEnvironment.device() => LinkClientEnvironment( + deviceName: _deviceName, + platform: Platform.isIOS ? 'ios' : 'android', + appVersion: AppInfo.version, + createBrowser: BonsoirLinkServiceBrowser.new, + createSession: (server, apiKey, device) => + LinkClientSession(server: server, apiKey: apiKey, device: device), + ensureLocalNetwork: LocalNetworkAccess.instance.ensureGranted, + onLocalNetwork: _onLocalNetwork, + ); + + static Future _deviceName() async { + try { + final info = DeviceInfoPlugin(); + if (Platform.isAndroid) { + final android = await info.androidInfo; + final name = android.name.trim(); + return name.isNotEmpty ? name : android.model; + } + if (Platform.isIOS) { + final ios = await info.iosInfo; + return ios.name.trim().isNotEmpty ? ios.name.trim() : ios.model; + } + } catch (error) { + _log.w('Reading the device name failed: $error'); + } + return Platform.isIOS ? 'iPhone' : 'Android'; + } + + static Future _onLocalNetwork() async { + try { + final results = await Connectivity().checkConnectivity(); + return results.contains(ConnectivityResult.wifi) || + results.contains(ConnectivityResult.ethernet); + } catch (_) { + // Unknown: do not warn about something we could not check. + return true; + } + } +} + +final linkClientEnvironmentProvider = Provider( + (ref) => LinkClientEnvironment.device(), +); + +final linkClientStoreProvider = Provider( + (ref) => LinkClientStore(), +); + +final linkPairingApiProvider = Provider( + (ref) => LinkPairingClient(), +); + +final linkLibraryBridgeProvider = Provider( + LinkNetworkLibraryBridge.new, +); + +@immutable +class LinkClientState { + const LinkClientState({ + this.loaded = false, + this.servers = const [], + this.activeServerId, + this.connection = LinkConnectionState.disconnected, + this.issue, + this.discovered = const [], + this.discovery = LinkDiscoveryStatus.idle, + this.localNetworkAvailable = true, + }); + + final bool loaded; + + /// Paired desktops, in pairing order. + final List servers; + + /// The desktop [linkActiveClientProvider] talks to. + final String? activeServerId; + + /// The active session's connection. + final LinkConnectionState connection; + + /// Why the active session last failed, cleared once it connects. + final LinkSessionIssue? issue; + + /// Desktops on the network while discovery runs. + final List discovered; + final LinkDiscoveryStatus discovery; + + /// False when neither Wi-Fi nor Ethernet is connected. + final bool localNetworkAvailable; + + LinkServerRecord? get activeServer => + servers.where((s) => s.serverId == activeServerId).firstOrNull; + + /// Discovered desktops this phone is not paired with. + List get unpaired => [ + for (final server in discovered) + if (!servers.any((s) => s.serverId == server.serverId)) server, + ]; + + LinkDiscoveredServer? discoveredServer(String serverId) => + discovered.where((s) => s.serverId == serverId).firstOrNull; + + /// Whether discovery sees [server] with another certificate than the one + /// it was paired with. + bool certificateChanged(LinkServerRecord server) { + final found = discoveredServer(server.serverId); + return found != null && found.fingerprint != server.fingerprint; + } + + LinkClientState copyWith({ + bool? loaded, + List? servers, + String? activeServerId, + bool clearActiveServer = false, + LinkConnectionState? connection, + LinkSessionIssue? issue, + bool clearIssue = false, + List? discovered, + LinkDiscoveryStatus? discovery, + bool? localNetworkAvailable, + }) => LinkClientState( + loaded: loaded ?? this.loaded, + servers: servers ?? this.servers, + activeServerId: clearActiveServer + ? null + : activeServerId ?? this.activeServerId, + connection: connection ?? this.connection, + issue: clearIssue ? null : issue ?? this.issue, + discovered: discovered ?? this.discovered, + discovery: discovery ?? this.discovery, + localNetworkAvailable: localNetworkAvailable ?? this.localNetworkAvailable, + ); +} + +/// The phone side of Mornye Link: paired desktops, discovery, pairing and +/// the active session it publishes through [linkActiveClientProvider]. +/// The app root keeps it alive on phones; it does nothing elsewhere. +class LinkClientController extends Notifier { + /// How long `catalog.changed` bursts settle before a rescan. + static const rescanDelay = Duration(seconds: 2); + + LinkSession? _session; + StreamSubscription? _stateSubscription; + StreamSubscription>? _messageSubscription; + LinkDiscovery? _discovery; + AppLifecycleListener? _lifecycle; + Timer? _rescan; + Future _mutation = Future.value(); + Future? _loading; + LinkDeviceIdentity? _device; + var _foreground = true; + var _discoveryHolds = 0; + var _discoveryBlocked = false; + + /// True until a supported build starts the client and after disposal, so + /// every entry point is inert on desktops. + var _disposed = true; + + LinkClientEnvironment get _environment => + ref.read(linkClientEnvironmentProvider); + LinkClientStore get _store => ref.read(linkClientStoreProvider); + LinkLibraryBridge get _library => ref.read(linkLibraryBridgeProvider); + + /// The active session, as [linkActiveClientProvider] publishes it. + LinkSession? get session => _session; + + /// Completes once paired desktops are loaded and the session started. + Future get ready => _loading ?? Future.value(); + + @override + LinkClientState build() { + if (!ref.watch(linkClientSupportedProvider)) { + return const LinkClientState(loaded: true); + } + _disposed = false; + _lifecycle = AppLifecycleListener(onStateChange: _onLifecycle); + ref.onDispose(_dispose); + _loading = Future.microtask( + () => _serial(_load).catchError( + (Object error, StackTrace stack) => + _log.e('Loading paired computers failed', error, stack), + ), + ); + return const LinkClientState(); + } + + Future _serial(Future Function() action) { + final result = _mutation.then((_) => action()); + _mutation = result.then((_) {}, onError: (Object _) {}); + return result; + } + + Future _load() async { + final store = _store; + final servers = await store.servers(); + var active = await store.activeServerId(); + if (_disposed) return; + if (!servers.any((s) => s.serverId == active)) { + active = servers.firstOrNull?.serverId; + } + state = state.copyWith( + loaded: true, + servers: servers, + activeServerId: active, + clearActiveServer: active == null, + ); + await _restartSession(); + } + + Future _identity() async { + final known = _device; + if (known != null) return known; + final environment = _environment; + final deviceId = await _store.deviceId(); + final name = await environment.deviceName(); + return _device = LinkDeviceIdentity( + deviceId: deviceId, + name: name, + platform: environment.platform, + appVersion: environment.appVersion, + ); + } + + /// Replaces the session with one for the active desktop. Runs serialized. + Future _restartSession() async { + final previous = _session; + _session = null; + await _stateSubscription?.cancel(); + await _messageSubscription?.cancel(); + _stateSubscription = null; + _messageSubscription = null; + _rescan?.cancel(); + final record = state.activeServer; + LinkSession? next; + LinkSessionIssue? issue; + if (record != null) { + final connection = await _library.connection(record.connectionId); + if (_disposed) { + await previous?.dispose(); + return; + } + if (connection == null || connection.apiKey.isEmpty) { + // The network connection was removed elsewhere: pair again. + issue = LinkSessionIssue.unauthorized; + } else { + next = _environment.createSession( + record, + connection.apiKey, + await _identity(), + ); + } + } + if (_disposed) { + await previous?.dispose(); + await next?.dispose(); + return; + } + _session = next; + if (next != null) { + final session = next; + _stateSubscription = session.connectionStates.listen( + (_) => _onConnection(session), + ); + _messageSubscription = session.messages.listen( + (message) => _onMessage(session, message), + ); + } + ref.read(linkActiveClientProvider.notifier).set(next); + state = state.copyWith( + connection: next?.connectionState ?? LinkConnectionState.disconnected, + issue: issue, + clearIssue: issue == null, + ); + await previous?.dispose(); + if (next != null) { + if (!_foreground) next.pause(); + next.start(); + } + _updateDiscovery(); + } + + void _onConnection(LinkSession session) { + if (_disposed || !identical(session, _session)) return; + state = state.copyWith( + connection: session.connectionState, + issue: session.issue, + clearIssue: session.issue == null, + ); + _updateDiscovery(); + } + + void _onMessage(LinkSession session, Map message) { + if (_disposed || !identical(session, _session)) return; + if (message['type'] != LinkMessageTypes.catalogChanged) return; + final connectionId = session.server.connectionId; + _rescan?.cancel(); + _rescan = Timer(rescanDelay, () { + _rescan = null; + unawaited( + _library + .rescan(connectionId) + .catchError( + (Object error) => + _log.w('Rescanning the computer failed: $error'), + ), + ); + }); + } + + void _onLifecycle(AppLifecycleState lifecycle) { + // Inactive covers the iOS control centre and app switcher; keep going. + if (lifecycle == AppLifecycleState.inactive) return; + final foreground = lifecycle == AppLifecycleState.resumed; + if (foreground == _foreground || _disposed) return; + _foreground = foreground; + if (foreground) { + _session?.resume(); + unawaited(refreshLocalNetwork()); + } else { + _session?.pause(); + } + _updateDiscovery(); + } + + /// Keeps discovery running while the returned callback is not called, for + /// the settings page. Discovery also runs on its own while the active + /// desktop is unreachable, to follow it to a new address. + /// + /// Pages call it from `initState` and release it from `dispose`, so the + /// state changes it causes wait for a microtask, after the frame. + VoidCallback acquireDiscovery() { + _discoveryHolds++; + _discoveryBlocked = false; + scheduleMicrotask(_updateDiscovery); + unawaited(Future.microtask(refreshLocalNetwork)); + var released = false; + return () { + if (released) return; + released = true; + _discoveryHolds--; + scheduleMicrotask(_updateDiscovery); + }; + } + + void _updateDiscovery() { + if (_disposed) return; + final wanted = + _foreground && + !_discoveryBlocked && + (_discoveryHolds > 0 || + (_session != null && + state.connection != LinkConnectionState.connected)); + final discovery = _discovery ??= LinkDiscovery( + createBrowser: _environment.createBrowser, + ensureAccess: _environment.ensureLocalNetwork, + onChanged: _onDiscoveryChanged, + ); + if (wanted && discovery.status != LinkDiscoveryStatus.searching) { + unawaited(discovery.start()); + } else if (!wanted && discovery.status == LinkDiscoveryStatus.searching) { + unawaited(discovery.stop()); + } + } + + void _onDiscoveryChanged() { + final discovery = _discovery; + if (_disposed || discovery == null) return; + final before = {for (final s in state.discovered) s.serverId}; + final found = discovery.servers; + if (discovery.status == LinkDiscoveryStatus.permissionDenied) { + // Do not ask again on every reconnect; the page offers a button. + _discoveryBlocked = true; + } + state = state.copyWith(discovered: found, discovery: discovery.status); + for (final server in found) { + final record = state.servers + .where((s) => s.serverId == server.serverId) + .firstOrNull; + // Another certificate under a known id is not followed anywhere. + if (record == null || record.fingerprint != server.fingerprint) continue; + if (record.address != server.address) { + unawaited(_serial(() => _move(record.serverId, server.address))); + } else if (!before.contains(server.serverId) && + record.serverId == state.activeServerId) { + _session?.reconnectNow(); + } + } + } + + Future _move(String serverId, String address) async { + final record = state.servers + .where((s) => s.serverId == serverId) + .firstOrNull; + if (record == null || record.address == address || _disposed) return; + _log.i('Computer ${record.name} moved to a new address'); + final servers = await _store.updateAddress(serverId, address); + await _library.updateAddress(record.connectionId, address); + if (_disposed) return; + state = state.copyWith(servers: servers); + final updated = servers.where((s) => s.serverId == serverId).firstOrNull; + final session = _session; + if (updated != null && + session != null && + serverId == state.activeServerId) { + session.updateServer(updated); + } + } + + /// Rechecks Wi-Fi for the page's warning. + Future refreshLocalNetwork() async { + if (_disposed) return; + final available = await _environment.onLocalNetwork(); + if (_disposed || available == state.localNetworkAvailable) return; + state = state.copyWith(localNetworkAvailable: available); + } + + /// Asks for local network access again, then retries discovery and the + /// session. Throws [LocalNetworkPermissionException] when refused. + Future requestLocalNetworkAccess() async { + if (_disposed) return; + await _environment.ensureLocalNetwork(); + if (_disposed) return; + _discoveryBlocked = false; + _updateDiscovery(); + _session?.reconnectNow(); + } + + /// Retries the active desktop now. + void retry() => _session?.reconnectNow(); + + /// Reads a desktop's `info` before asking for its PIN. + Future probe( + String host, + int port, { + String? expectedFingerprint, + }) { + final address = linkServerAddress(host, port); + if (address == null) { + return Future.error( + const LinkPairingException(LinkPairingError.invalidAddress), + ); + } + return ref + .read(linkPairingApiProvider) + .probe(address, expectedFingerprint: expectedFingerprint); + } + + /// Pairs with [target] using [pin]. On success the desktop is saved as a + /// Subsonic network connection, added to Library and scanned; re-pairing + /// replaces the stored key. Throws [LinkPairingException]. + Future pair(LinkPairingTarget target, String pin) async { + final result = await ref + .read(linkPairingApiProvider) + .pair(target, pin: pin, device: await _identity()); + final (record, connection) = await _serial(() async { + final existing = state.servers + .where((s) => s.serverId == result.serverId) + .firstOrNull; + final name = result.name.isNotEmpty + ? result.name + : Uri.parse(target.address).host; + final connection = NetworkConnection( + id: existing?.connectionId ?? NetworkStorageService.newId(), + name: name, + protocol: NetworkProtocol.subsonic, + address: target.address, + subsonicAuth: SubsonicAuth.apiKey, + apiKey: result.apiKey, + trustedCertificateSha256: result.fingerprint, + ); + await _library.saveConnection(connection); + final record = LinkServerRecord( + serverId: result.serverId, + name: name, + connectionId: connection.id, + address: target.address, + fingerprint: result.fingerprint, + ); + final servers = await _store.upsert(record); + var active = state.activeServerId; + if (active == null || !servers.any((s) => s.serverId == active)) { + active = record.serverId; + await _store.setActiveServerId(active); + } + if (!_disposed) { + state = state.copyWith(servers: servers, activeServerId: active); + if (active == record.serverId) await _restartSession(); + } + return (record, connection); + }); + unawaited( + _library + .addLibrarySource(connection) + .catchError( + (Object error) => + _log.w('Adding the computer to Library failed: $error'), + ), + ); + return record; + } + + /// Makes [serverId] the desktop features talk to. + Future setActive(String serverId) => _serial(() async { + if (state.activeServerId == serverId || + !state.servers.any((s) => s.serverId == serverId)) { + return; + } + await _store.setActiveServerId(serverId); + if (_disposed) return; + state = state.copyWith(activeServerId: serverId); + await _restartSession(); + }); + + /// Forgets a paired desktop. With [removeLibrary] its network connection + /// and Library source go too; otherwise its music stays browsable. + Future forget(String serverId, {required bool removeLibrary}) => + _serial(() async { + final record = state.servers + .where((s) => s.serverId == serverId) + .firstOrNull; + if (record == null) return; + final servers = await _store.remove(serverId); + final wasActive = state.activeServerId == serverId; + final active = wasActive + ? servers.firstOrNull?.serverId + : state.activeServerId; + if (wasActive) await _store.setActiveServerId(active); + if (!_disposed) { + state = state.copyWith( + servers: servers, + activeServerId: active, + clearActiveServer: active == null, + ); + if (wasActive) await _restartSession(); + } + if (removeLibrary) await _library.removeConnection(record.connectionId); + }); + + void _dispose() { + _disposed = true; + _lifecycle?.dispose(); + _lifecycle = null; + _rescan?.cancel(); + unawaited(_stateSubscription?.cancel()); + unawaited(_messageSubscription?.cancel()); + final discovery = _discovery; + _discovery = null; + unawaited(discovery?.stop()); + final session = _session; + _session = null; + unawaited(session?.dispose()); + } +} + +final linkClientControllerProvider = + NotifierProvider( + LinkClientController.new, + ); diff --git a/lib/services/link/client/link_client_discovery.dart b/lib/services/link/client/link_client_discovery.dart new file mode 100644 index 000000000..6323e6d68 --- /dev/null +++ b/lib/services/link/client/link_client_discovery.dart @@ -0,0 +1,262 @@ +import 'dart:async'; +import 'dart:io'; + +import 'package:flutter/foundation.dart'; +import 'package:mornye/services/link/link_protocol.dart'; +import 'package:mornye/services/local_network_access.dart'; +import 'package:mornye/utils/logger.dart'; + +final _log = AppLogger('LinkDiscovery'); + +/// One mDNS event for [linkServiceType], independent of the plugin. +sealed class LinkServiceEvent { + const LinkServiceEvent(this.name); + + /// The mDNS instance name, which the desktop sets to its server name. + final String name; +} + +/// A service was resolved, or its record changed. +class LinkServiceResolved extends LinkServiceEvent { + const LinkServiceResolved({ + required String name, + required this.port, + this.addresses = const [], + this.hostname, + this.attributes = const {}, + }) : super(name); + + final int port; + + /// Addresses as the platform reports them, IPv4 or IPv6. + final List addresses; + + /// The SRV target, usually `.local`, when the platform reports it. + final String? hostname; + + /// TXT record: `v`, `id` and `fp`. + final Map attributes; +} + +/// A service left the network. +class LinkServiceLost extends LinkServiceEvent { + const LinkServiceLost(super.name); +} + +/// Browses the local network for desktops. The app uses Bonsoir; tests feed +/// events by hand. +abstract interface class LinkServiceBrowser { + /// Starts browsing; resolved and lost services arrive until [stop]. + Future> start(); + + Future stop(); +} + +/// A desktop found on the local network. +@immutable +class LinkDiscoveredServer { + const LinkDiscoveredServer({ + required this.serviceName, + required this.serverId, + required this.name, + required this.host, + required this.port, + required this.fingerprint, + }); + + /// The mDNS instance name, which identifies the service in lost events. + final String serviceName; + final String serverId; + final String name; + final String host; + final int port; + + /// The certificate fingerprint the desktop advertises (TXT `fp`). Pairing + /// still checks it against the certificate it actually sees. + final String fingerprint; + + /// `https://host:port`, the form of [LinkServerRecord.address]. + String get address => Uri(scheme: 'https', host: host, port: port).toString(); + + @override + bool operator ==(Object other) => + other is LinkDiscoveredServer && + other.serviceName == serviceName && + other.serverId == serverId && + other.name == name && + other.host == host && + other.port == port && + other.fingerprint == fingerprint; + + @override + int get hashCode => + Object.hash(serviceName, serverId, name, host, port, fingerprint); + + @override + String toString() => 'LinkDiscoveredServer($name, $serverId, $address)'; +} + +final _fingerprintPattern = RegExp(r'^[0-9a-f]{64}$'); + +/// The desktop behind a resolved service, or null when it is not a Mornye +/// Link server of this protocol or has no usable address. +LinkDiscoveredServer? linkDiscoveredServerFrom(LinkServiceResolved service) { + final attributes = service.attributes; + if (attributes['v']?.trim() != '$linkProtocolVersion') return null; + final serverId = attributes['id']?.trim() ?? ''; + final fingerprint = attributes['fp']?.trim().toLowerCase() ?? ''; + if (serverId.isEmpty || !_fingerprintPattern.hasMatch(fingerprint)) { + return null; + } + if (service.port < 1 || service.port > 65535) return null; + final host = linkPreferredHost(service.addresses, service.hostname); + if (host == null) return null; + final name = service.name.trim(); + return LinkDiscoveredServer( + serviceName: service.name, + serverId: serverId, + name: name.isEmpty ? host : name, + host: host, + port: service.port, + fingerprint: fingerprint, + ); +} + +/// The address to reach a desktop at: IPv4 first, since it needs no zone, +/// then a routable IPv6 address, then the mDNS host name. Link-local IPv6 +/// is skipped because a URL cannot carry its interface reliably. +@visibleForTesting +String? linkPreferredHost(List addresses, String? hostname) { + final parsed = [ + for (final address in addresses) + ?InternetAddress.tryParse(address.split('%').first.trim()), + ]; + for (final address in parsed) { + if (address.type == InternetAddressType.IPv4 && !address.isLoopback) { + return address.address; + } + } + for (final address in parsed) { + if (address.type == InternetAddressType.IPv6 && + !address.isLoopback && + !address.isLinkLocal) { + return address.address; + } + } + final name = hostname?.trim().replaceFirst(RegExp(r'\.$'), '') ?? ''; + return name.isEmpty ? null : name; +} + +enum LinkDiscoveryStatus { idle, searching, permissionDenied, failed } + +/// Keeps the list of desktops on the network while browsing runs. +class LinkDiscovery { + LinkDiscovery({ + required LinkServiceBrowser Function() createBrowser, + required void Function() onChanged, + Future Function()? ensureAccess, + }) : _createBrowser = createBrowser, + _onChanged = onChanged, + _ensureAccess = + ensureAccess ?? LocalNetworkAccess.instance.ensureGranted; + + final LinkServiceBrowser Function() _createBrowser; + final void Function() _onChanged; + final Future Function() _ensureAccess; + final _byService = {}; + LinkServiceBrowser? _browser; + StreamSubscription? _subscription; + var _generation = 0; + var _status = LinkDiscoveryStatus.idle; + + LinkDiscoveryStatus get status => _status; + + /// Whether browsing was asked for and has not stopped or failed. + bool get running => _status == LinkDiscoveryStatus.searching; + + /// Desktops on the network, one per server id, sorted by name. + List get servers { + final byServer = {}; + for (final server in _byService.values) { + byServer[server.serverId] = server; + } + return byServer.values.toList() + ..sort((a, b) => a.name.toLowerCase().compareTo(b.name.toLowerCase())); + } + + Future start() async { + if (running) return; + final generation = ++_generation; + _status = LinkDiscoveryStatus.searching; + _onChanged(); + try { + await _ensureAccess(); + if (generation != _generation) return; + final browser = _browser = _createBrowser(); + final events = await browser.start(); + if (generation != _generation) { + await browser.stop(); + return; + } + _subscription = events.listen( + (event) => _handle(generation, event), + onError: (Object error) => _fail(generation, error), + ); + } catch (error) { + _fail(generation, error); + } + } + + Future stop() async { + _generation++; + final subscription = _subscription; + final browser = _browser; + _subscription = null; + _browser = null; + final changed = + _byService.isNotEmpty || _status == LinkDiscoveryStatus.searching; + _byService.clear(); + if (_status == LinkDiscoveryStatus.searching) { + _status = LinkDiscoveryStatus.idle; + } + if (changed) _onChanged(); + await subscription?.cancel(); + try { + await browser?.stop(); + } catch (error) { + _log.w('Stopping discovery failed: $error'); + } + } + + void _handle(int generation, LinkServiceEvent event) { + if (generation != _generation) return; + switch (event) { + case LinkServiceResolved(): + final server = linkDiscoveredServerFrom(event); + // An update without addresses keeps the last resolved entry. + if (server == null || _byService[event.name] == server) return; + _byService[event.name] = server; + case LinkServiceLost(): + if (_byService.remove(event.name) == null) return; + } + _onChanged(); + } + + void _fail(int generation, Object error) { + if (generation != _generation) return; + _generation++; + final browser = _browser; + _browser = null; + unawaited(_subscription?.cancel()); + _subscription = null; + unawaited(browser?.stop().catchError((Object _) {})); + _byService.clear(); + _status = error is LocalNetworkPermissionException + ? LinkDiscoveryStatus.permissionDenied + : LinkDiscoveryStatus.failed; + if (_status == LinkDiscoveryStatus.failed) { + _log.w('Discovery failed: $error'); + } + _onChanged(); + } +} diff --git a/lib/services/link/client/link_client_http.dart b/lib/services/link/client/link_client_http.dart new file mode 100644 index 000000000..3c9bc29ad --- /dev/null +++ b/lib/services/link/client/link_client_http.dart @@ -0,0 +1,205 @@ +import 'dart:async'; +import 'dart:convert'; +import 'dart:io'; +import 'dart:typed_data'; + +import 'package:crypto/crypto.dart'; +import 'package:mornye/services/link/link_protocol.dart'; +import 'package:mornye/services/local_network_access.dart'; + +/// Requests to the desktop give up after this long. +const linkRequestTimeout = Duration(seconds: 20); + +/// Response bodies above this size are refused (the server's request limit). +const _maxBodyBytes = 8 * 1024 * 1024; + +/// Error codes the phone adds to the contract's `invalid`, `not_found`, +/// `unavailable` and `timeout` when the failure happens on the way. +abstract final class LinkClientErrors { + static const unauthorized = 'unauthorized'; + static const certificate = 'certificate'; + static const unavailable = 'unavailable'; + static const timeout = 'timeout'; + static const invalid = 'invalid'; + static const localNetworkPermission = 'local_network_permission'; +} + +/// The certificate fingerprint as the contract and the network storage trust +/// store write it: lowercase hex SHA-256 of the DER bytes. +String linkCertificateFingerprint(X509Certificate certificate) => + sha256.convert(certificate.der).toString(); + +/// `https://host:port` for a desktop, or null when [host] or [port] cannot +/// form one. IPv6 literals are bracketed; a scheme or path is refused. +Uri? linkServerAddress(String host, int port) { + final trimmed = host.trim().replaceAll(RegExp(r'^\[|\]$'), ''); + if (trimmed.isEmpty || + port < 1 || + port > 65535 || + trimmed.contains('/') || + trimmed.contains('@') || + trimmed.contains(' ') || + (trimmed.contains(':') && InternetAddress.tryParse(trimmed) == null)) { + return null; + } + try { + return Uri(scheme: 'https', host: trimmed, port: port); + } on FormatException { + return null; + } +} + +/// An [HttpClient] that trusts exactly the certificate whose fingerprint is +/// [fingerprint]. It loads no CA roots, so every handshake reaches the +/// callback and nothing but the pinned certificate passes, not even a +/// publicly trusted one. +HttpClient linkPinnedHttpClient(String fingerprint) { + final pin = fingerprint.toLowerCase(); + return HttpClient(context: SecurityContext(withTrustedRoots: false)) + ..connectionTimeout = linkRequestTimeout + ..idleTimeout = const Duration(seconds: 15) + ..badCertificateCallback = (certificate, _, _) => + linkCertificateFingerprint(certificate) == pin; +} + +/// An [HttpClient] for first contact with an unpaired desktop. It accepts the +/// certificate presented by [target]'s host and port, and no other host, so +/// the caller can read the fingerprint from the response +/// ([LinkHttpResponse.certificateFingerprint]) and compare it with what the +/// desktop claims before trusting anything. +HttpClient linkFirstContactHttpClient(Uri target) => + HttpClient(context: SecurityContext(withTrustedRoots: false)) + ..connectionTimeout = linkRequestTimeout + ..badCertificateCallback = (_, host, port) => + host == target.host && port == target.port; + +class LinkHttpResponse { + const LinkHttpResponse({ + required this.statusCode, + this.body, + this.certificateFingerprint, + }); + + final int statusCode; + + /// The decoded JSON body, or null when it was empty or not JSON. + final Object? body; + + /// The fingerprint of the certificate the server presented, or null over + /// plain HTTP. + final String? certificateFingerprint; + + bool get ok => statusCode >= 200 && statusCode < 300; +} + +/// Sends one JSON request and reads the whole JSON answer. +Future linkHttpSend( + HttpClient client, + String method, + Uri uri, { + Map headers = const {}, + Map? json, + Duration timeout = linkRequestTimeout, +}) async { + var expired = false; + final request = await client + .openUrl(method, uri) + .then((request) { + if (expired) request.abort(); + return request; + }) + .timeout( + timeout, + onTimeout: () { + expired = true; + throw TimeoutException('The computer did not answer in time'); + }, + ); + final HttpClientResponse response; + try { + request.followRedirects = false; + request.headers.set(HttpHeaders.acceptHeader, 'application/json'); + headers.forEach(request.headers.set); + if (json != null) { + final bytes = utf8.encode(jsonEncode(json)); + request.headers.contentType = ContentType.json; + request.contentLength = bytes.length; + request.add(bytes); + } + response = await request.close().timeout(timeout); + } catch (_) { + request.abort(); + rethrow; + } + final certificate = response.certificate; + final bytes = BytesBuilder(copy: false); + await for (final chunk in response.timeout(timeout)) { + if (bytes.length + chunk.length > _maxBodyBytes) { + throw const HttpException('The computer sent too much data'); + } + bytes.add(chunk); + } + Object? body; + if (bytes.isNotEmpty) { + try { + body = jsonDecode(utf8.decode(bytes.takeBytes())); + } on FormatException { + body = null; + } + } + return LinkHttpResponse( + statusCode: response.statusCode, + body: body, + certificateFingerprint: certificate == null + ? null + : linkCertificateFingerprint(certificate), + ); +} + +/// The [LinkException] for a failed response: the body's +/// `{"error","message"}` when present, else a code from the status. +LinkException linkResponseException(LinkHttpResponse response) { + final body = response.body; + if (body is Map && body['error'] is String) { + final message = body['message']; + return LinkException( + body['error'] as String, + message is String ? message : '', + ); + } + final status = response.statusCode; + return LinkException(switch (status) { + 400 => LinkClientErrors.invalid, + 401 => LinkClientErrors.unauthorized, + 404 => 'not_found', + 503 => LinkClientErrors.unavailable, + 504 => LinkClientErrors.timeout, + _ => 'http_$status', + }, 'HTTP $status'); +} + +/// The [LinkException] for a transport failure. Messages stay generic, so no +/// address or credential leaks into logs or the UI. +LinkException linkTransportException(Object error) => switch (error) { + LinkException() => error, + TimeoutException() => const LinkException( + LinkClientErrors.timeout, + 'The computer did not answer in time', + ), + LocalNetworkPermissionException() => const LinkException( + LinkClientErrors.localNetworkPermission, + 'Local network access is not allowed', + ), + TlsException() => const LinkException( + LinkClientErrors.certificate, + 'The computer presented another certificate', + ), + WebSocketException(httpStatusCode: 401) => const LinkException( + LinkClientErrors.unauthorized, + 'The computer no longer accepts this phone', + ), + _ => const LinkException( + LinkClientErrors.unavailable, + 'The computer could not be reached', + ), +}; diff --git a/lib/services/link/client/link_client_library.dart b/lib/services/link/client/link_client_library.dart new file mode 100644 index 000000000..4e8d2e7b7 --- /dev/null +++ b/lib/services/link/client/link_client_library.dart @@ -0,0 +1,149 @@ +import 'dart:async'; + +import 'package:flutter_riverpod/flutter_riverpod.dart'; +import 'package:mornye/providers/local_library_provider.dart'; +import 'package:mornye/providers/settings_provider.dart'; +import 'package:mornye/services/library_database.dart'; +import 'package:mornye/services/network_storage_service.dart'; +import 'package:mornye/utils/logger.dart'; + +final _log = AppLogger('LinkLibrary'); + +/// Where a paired desktop meets the existing network storage and Library: +/// its Subsonic connection and its Library source. Faked in tests. +abstract interface class LinkLibraryBridge { + Future connection(String connectionId); + + Future saveConnection(NetworkConnection connection); + + /// Points the connection at the desktop's new `https://host:port`. + Future updateAddress(String connectionId, String address); + + /// Adds the connection's root to Library and scans it, as the network + /// storage screen does after adding a Subsonic server. + Future addLibrarySource(NetworkConnection connection); + + /// Rescans the connection's Library source incrementally, after any + /// running scan. + Future rescan(String connectionId); + + /// Removes the Library source and the saved connection. + Future removeConnection(String connectionId); +} + +class LinkNetworkLibraryBridge implements LinkLibraryBridge { + LinkNetworkLibraryBridge( + this._ref, { + NetworkStorageService? storage, + LibraryDatabase? database, + }) : _storage = storage ?? NetworkStorageService.instance, + _database = database ?? LibraryDatabase.instance; + + final Ref _ref; + final NetworkStorageService _storage; + final LibraryDatabase _database; + final _pendingScans = {}; + ProviderSubscription? _scanWatch; + + static String _rootSource(String connectionId) => + NetworkStorageService.source(connectionId, ''); + + @override + Future connection(String connectionId) async { + try { + return await _storage.connection(connectionId); + } on StateError { + return null; + } + } + + @override + Future saveConnection(NetworkConnection connection) => + _storage.save(connection); + + @override + Future updateAddress(String connectionId, String address) async { + final current = await connection(connectionId); + if (current == null || current.address == address) return; + await _storage.save( + NetworkConnection( + id: current.id, + name: current.name, + protocol: current.protocol, + address: address, + username: current.username, + password: current.password, + domain: current.domain, + trustedCertificateSha256: current.trustedCertificateSha256, + subsonicAuth: current.subsonicAuth, + apiKey: current.apiKey, + ), + ); + } + + @override + Future addLibrarySource(NetworkConnection connection) async { + final source = await _ref + .read(localLibraryProvider.notifier) + .addSource( + path: _rootSource(connection.id), + displayName: connection.name, + ); + _ref.read(settingsProvider.notifier).setLocalLibraryEnabled(true); + _scan(source.id); + } + + @override + Future rescan(String connectionId) async { + final source = await _database.getSourceByPath(_rootSource(connectionId)); + if (source == null || !source.enabled) return; + _scan(source.id); + } + + void _scan(String sourceId) { + if (_ref.read(localLibraryProvider).isScanning) { + // A request during another scan would be dropped; run it afterwards. + _pendingScans.add(sourceId); + _scanWatch ??= _ref.listen( + localLibraryProvider.select((state) => state.isScanning), + (_, scanning) { + if (!scanning) _drainPending(); + }, + ); + return; + } + unawaited( + _ref + .read(localLibraryProvider.notifier) + .startSourceScan(sourceId) + .catchError((Object error) => _log.w('Library scan failed: $error')), + ); + } + + void _drainPending() { + _scanWatch?.close(); + _scanWatch = null; + final pending = _pendingScans.toList(); + _pendingScans.clear(); + unawaited(() async { + final library = _ref.read(localLibraryProvider.notifier); + for (final sourceId in pending) { + try { + await library.startSourceScan(sourceId); + } catch (error) { + _log.w('Library scan failed: $error'); + } + } + }()); + } + + @override + Future removeConnection(String connectionId) async { + final source = await _database.getSourceByPath(_rootSource(connectionId)); + if (source != null) { + _pendingScans.remove(source.id); + await _ref.read(localLibraryProvider.notifier).removeSource(source.id); + } + await _storage.remove(connectionId); + } +} diff --git a/lib/services/link/client/link_client_pairing.dart b/lib/services/link/client/link_client_pairing.dart new file mode 100644 index 000000000..799e4e31b --- /dev/null +++ b/lib/services/link/client/link_client_pairing.dart @@ -0,0 +1,276 @@ +import 'dart:async'; +import 'dart:io'; + +import 'package:flutter/foundation.dart'; +import 'package:mornye/services/link/client/link_client_http.dart'; +import 'package:mornye/services/link/link_protocol.dart'; +import 'package:mornye/services/local_network_access.dart'; + +/// How this phone introduces itself to a desktop. +@immutable +class LinkDeviceIdentity { + const LinkDeviceIdentity({ + required this.deviceId, + required this.name, + required this.platform, + required this.appVersion, + }); + + final String deviceId; + final String name; + + /// `android` or `ios`. + final String platform; + final String appVersion; +} + +/// A desktop ready for its PIN: its `info`, read over a connection whose +/// certificate matched the fingerprint it claims. +@immutable +class LinkPairingTarget { + const LinkPairingTarget({required this.address, required this.info}); + + /// `https://host:port`. + final String address; + final LinkServerInfo info; + + /// The fingerprint seen in the handshake, equal to [LinkServerInfo.fingerprint]. + String get fingerprint => info.fingerprint; + + /// The first 8 hex characters, which the desktop shows next to its PIN. + String get shortFingerprint => fingerprint.substring(0, 8); +} + +@immutable +class LinkPairingResult { + const LinkPairingResult({ + required this.apiKey, + required this.serverId, + required this.name, + required this.fingerprint, + }); + + final String apiKey; + final String serverId; + final String name; + final String fingerprint; +} + +enum LinkPairingError { + /// The certificate in the handshake differs from the fingerprint the + /// desktop (or its mDNS record) claims: possibly someone in between. + certificateMismatch, + + /// Not a Mornye desktop, or another protocol version. + incompatible, + invalidAddress, + + /// The desktop answered `bad_proof`: the PIN is wrong. + badPin, + + /// The desktop answered `pairing_closed`: no pairing window is open. + pairingClosed, + + /// The desktop answered 429. + tooManyAttempts, + localNetworkPermission, + unreachable, + timeout, + failed, +} + +class LinkPairingException implements Exception { + const LinkPairingException(this.error); + + final LinkPairingError error; + + @override + String toString() => 'LinkPairingException(${error.name})'; +} + +/// Pairing as the settings page drives it; faked in widget tests. +abstract interface class LinkPairingApi { + /// Reads `GET /mornye/v1/info` at [address] and checks the certificate. + /// [expectedFingerprint] is the one mDNS advertised, when known. + Future probe(Uri address, {String? expectedFingerprint}); + + /// Sends the PIN proof; returns the device's API key. + Future pair( + LinkPairingTarget target, { + required String pin, + required LinkDeviceIdentity device, + }); +} + +final _pinPattern = RegExp(r'^\d{6}$'); + +/// Contract section 3 over HTTPS: first contact records the certificate, +/// then every request is pinned to it. +class LinkPairingClient implements LinkPairingApi { + LinkPairingClient({ + Future Function(Uri)? ensureAccess, + HttpClient Function(Uri target)? firstContactClient, + HttpClient Function(String fingerprint)? pinnedClient, + Duration timeout = linkRequestTimeout, + }) : _ensureAccess = ensureAccess ?? LocalNetworkAccess.instance.ensureAccess, + _firstContactClient = firstContactClient ?? linkFirstContactHttpClient, + _pinnedClient = pinnedClient ?? linkPinnedHttpClient, + _timeout = timeout; + + final Future Function(Uri) _ensureAccess; + final HttpClient Function(Uri target) _firstContactClient; + final HttpClient Function(String fingerprint) _pinnedClient; + final Duration _timeout; + + @override + Future probe( + Uri address, { + String? expectedFingerprint, + }) async { + if (address.scheme != 'https' || address.host.isEmpty) { + throw const LinkPairingException(LinkPairingError.invalidAddress); + } + final origin = Uri(scheme: 'https', host: address.host, port: address.port); + final client = _firstContactClient(origin); + try { + await _ensureAccess(origin); + final response = await linkHttpSend( + client, + 'GET', + origin.replace(path: '$linkApiPath/info'), + timeout: _timeout, + ); + if (!response.ok) { + throw const LinkPairingException(LinkPairingError.incompatible); + } + final info = + LinkServerInfo.fromJson(response.body) ?? + (throw const LinkPairingException(LinkPairingError.incompatible)); + final observed = response.certificateFingerprint; + if (!linkFingerprintsMatch( + observed: observed, + claimed: info.fingerprint, + advertised: expectedFingerprint, + )) { + throw const LinkPairingException(LinkPairingError.certificateMismatch); + } + if (info.protocol != linkProtocolVersion) { + throw const LinkPairingException(LinkPairingError.incompatible); + } + return LinkPairingTarget(address: origin.toString(), info: info); + } catch (error) { + throw _classify(error); + } finally { + client.close(force: true); + } + } + + @override + Future pair( + LinkPairingTarget target, { + required String pin, + required LinkDeviceIdentity device, + }) async { + if (!_pinPattern.hasMatch(pin)) { + throw const LinkPairingException(LinkPairingError.badPin); + } + final origin = Uri.parse(target.address); + final client = _pinnedClient(target.fingerprint); + try { + await _ensureAccess(origin); + final response = await linkHttpSend( + client, + 'POST', + origin.replace(path: '$linkApiPath/pair'), + json: { + 'deviceId': device.deviceId, + 'name': device.name, + 'platform': device.platform, + 'proof': linkPairingProof( + pin: pin, + fingerprint: target.fingerprint, + deviceId: device.deviceId, + ), + }, + timeout: _timeout, + ); + final observed = response.certificateFingerprint; + if (observed != null && observed != target.fingerprint) { + throw const LinkPairingException(LinkPairingError.certificateMismatch); + } + final body = response.body; + if (response.statusCode == 429) { + throw const LinkPairingException(LinkPairingError.tooManyAttempts); + } + if (response.statusCode == 403) { + throw LinkPairingException(switch (body is Map ? body['error'] : null) { + 'bad_proof' => LinkPairingError.badPin, + 'pairing_closed' => LinkPairingError.pairingClosed, + _ => LinkPairingError.failed, + }); + } + if (!response.ok || body is! Map) { + throw const LinkPairingException(LinkPairingError.failed); + } + final apiKey = body['apiKey']; + final serverId = body['serverId']; + final fingerprint = body['fingerprint']; + if (apiKey is! String || apiKey.isEmpty) { + throw const LinkPairingException(LinkPairingError.failed); + } + if (serverId is String && serverId != target.info.serverId) { + throw const LinkPairingException(LinkPairingError.incompatible); + } + if (fingerprint is String && + fingerprint.toLowerCase() != target.fingerprint) { + throw const LinkPairingException(LinkPairingError.certificateMismatch); + } + final name = body['name']; + return LinkPairingResult( + apiKey: apiKey, + serverId: target.info.serverId, + name: name is String && name.trim().isNotEmpty + ? name.trim() + : target.info.name, + fingerprint: target.fingerprint, + ); + } catch (error) { + throw _classify(error); + } finally { + client.close(force: true); + } + } + + static LinkPairingException _classify(Object error) => switch (error) { + LinkPairingException() => error, + LocalNetworkPermissionException() => const LinkPairingException( + LinkPairingError.localNetworkPermission, + ), + // The pinned client refuses any other certificate during the handshake. + TlsException() => const LinkPairingException( + LinkPairingError.certificateMismatch, + ), + TimeoutException() => const LinkPairingException(LinkPairingError.timeout), + SocketException() => const LinkPairingException( + LinkPairingError.unreachable, + ), + FormatException() => const LinkPairingException( + LinkPairingError.invalidAddress, + ), + _ => const LinkPairingException(LinkPairingError.failed), + }; +} + +/// Whether the certificate seen in the handshake ([observed]) is the one the +/// desktop claims in `info` and, when known, the one its mDNS record +/// advertises. Without an observed certificate nothing can be trusted. +bool linkFingerprintsMatch({ + required String? observed, + required String claimed, + String? advertised, +}) { + if (observed == null || observed.isEmpty) return false; + final seen = observed.toLowerCase(); + return seen == claimed.toLowerCase() && + (advertised == null || advertised.toLowerCase() == seen); +} diff --git a/lib/services/link/client/link_client_session.dart b/lib/services/link/client/link_client_session.dart new file mode 100644 index 000000000..39e1965aa --- /dev/null +++ b/lib/services/link/client/link_client_session.dart @@ -0,0 +1,470 @@ +import 'dart:async'; +import 'dart:convert'; +import 'dart:io'; +import 'dart:math'; + +import 'package:mornye/services/link/client/link_client_http.dart'; +import 'package:mornye/services/link/client/link_client_pairing.dart'; +import 'package:mornye/services/link/link_client_api.dart'; +import 'package:mornye/services/link/link_protocol.dart'; +import 'package:mornye/services/local_network_access.dart'; +import 'package:mornye/utils/logger.dart'; + +final _log = AppLogger('LinkSession'); + +/// Why the session last failed to connect, for the settings page. +enum LinkSessionIssue { + unreachable, + + /// The desktop refused the API key (revoked, or the record lost its key). + unauthorized, + + /// The desktop presented a certificate other than the pinned one. + certificate, + localNetworkPermission, + + /// The desktop speaks another protocol version. + incompatible, +} + +/// A [LinkClientApi] the client controller can drive. +abstract interface class LinkSession implements LinkClientApi { + LinkSessionIssue? get issue; + + /// Connects and keeps reconnecting until [dispose]. + void start(); + + /// Closes the socket and stops retrying (app in the background). + void pause(); + + /// Reconnects at once after [pause]. + void resume(); + + /// Skips the remaining backoff (discovery saw the desktop again). + void reconnectNow(); + + /// Uses [server]'s new address; reconnects when it changed. + void updateServer(LinkServerRecord server); + + Future dispose(); +} + +/// The WebSocket as the session uses it, so tests can fake it. +abstract interface class LinkSocket { + Stream get stream; + int? get closeCode; + void add(String data); + Future close([int? code, String? reason]); +} + +typedef LinkSocketConnector = + Future Function( + Uri uri, + Map headers, + HttpClient client, + ); + +typedef LinkTimerFactory = Timer Function(Duration delay, void Function() run); + +class _WebSocketLinkSocket implements LinkSocket { + _WebSocketLinkSocket(this._socket) { + // The desktop pings every 20 s; pinging back finds a vanished desktop. + _socket.pingInterval = const Duration(seconds: 20); + } + + final WebSocket _socket; + + @override + Stream get stream => _socket; + + @override + int? get closeCode => _socket.closeCode; + + @override + void add(String data) => _socket.add(data); + + @override + Future close([int? code, String? reason]) => + _socket.close(code, reason); +} + +/// Opens the desktop's WebSocket over the session's (pinned) client. +Future linkConnectWebSocket( + Uri uri, + Map headers, + HttpClient client, +) async => _WebSocketLinkSocket( + await WebSocket.connect( + uri.toString(), + headers: headers, + customClient: client, + ), +); + +/// WebSocket close code for a key that belongs to another device. +const linkCloseUnauthorized = 4401; + +final _opPattern = RegExp(r'^[A-Za-z0-9_.-]+(/[A-Za-z0-9_.-]+)*$'); + +/// Whether [op] names a path under the API: plain segments, none of them +/// `.` or `..`, which would resolve outside `/mornye/v1`. +bool _validOp(String op) => + _opPattern.hasMatch(op) && + op.split('/').every((segment) => segment != '.' && segment != '..'); + +/// The phone's live session with one paired desktop: Bearer JSON requests +/// and the WebSocket (`hello`, `welcome`, pushed messages), reconnecting +/// with backoff from [minBackoff] doubling to [maxBackoff]. +class LinkClientSession implements LinkSession { + LinkClientSession({ + required LinkServerRecord server, + required String apiKey, + required LinkDeviceIdentity device, + HttpClient Function(LinkServerRecord server)? httpClient, + LinkSocketConnector? connectSocket, + Future Function(Uri)? ensureAccess, + LinkTimerFactory? timer, + Duration requestTimeout = linkRequestTimeout, + Duration handshakeTimeout = const Duration(seconds: 15), + }) : _server = server, + _apiKey = apiKey, + _device = device, + _createHttpClient = + httpClient ?? ((server) => linkPinnedHttpClient(server.fingerprint)), + _connectSocket = connectSocket ?? linkConnectWebSocket, + _ensureAccess = ensureAccess ?? LocalNetworkAccess.instance.ensureAccess, + _timer = timer ?? Timer.new, + _requestTimeout = requestTimeout, + _handshakeTimeout = handshakeTimeout; + + static const minBackoff = Duration(seconds: 1); + static const maxBackoff = Duration(seconds: 30); + + LinkServerRecord _server; + final String _apiKey; + final LinkDeviceIdentity _device; + final HttpClient Function(LinkServerRecord server) _createHttpClient; + final LinkSocketConnector _connectSocket; + final Future Function(Uri) _ensureAccess; + final LinkTimerFactory _timer; + final Duration _requestTimeout; + final Duration _handshakeTimeout; + + final _states = StreamController.broadcast(); + final _messages = StreamController>.broadcast(); + HttpClient? _http; + LinkSocket? _socket; + StreamSubscription? _subscription; + Timer? _retry; + var _state = LinkConnectionState.disconnected; + LinkSessionIssue? _issue; + var _backoff = minBackoff; + var _attempt = 0; + var _started = false; + var _paused = false; + var _disposed = false; + + @override + LinkServerRecord get server => _server; + + @override + LinkConnectionState get connectionState => _state; + + @override + Stream get connectionStates => _states.stream; + + @override + Stream> get messages => _messages.stream; + + @override + LinkSessionIssue? get issue => _issue; + + HttpClient get _client => _http ??= _createHttpClient(_server); + + Uri get _origin => Uri.parse(_server.address); + + Map get _authorization => { + HttpHeaders.authorizationHeader: 'Bearer $_apiKey', + }; + + void _setState(LinkConnectionState next) { + if (_state == next || _disposed) return; + _state = next; + _states.add(next); + } + + @override + void start() { + if (_disposed) return; + _started = true; + unawaited(_connect()); + } + + @override + void pause() { + if (_disposed || _paused) return; + _paused = true; + _dropSocket(1001); + } + + @override + void resume() { + if (_disposed || !_paused) return; + _paused = false; + _backoff = minBackoff; + unawaited(_connect()); + } + + @override + void reconnectNow() { + if (_disposed || _paused || !_started) return; + if (_state != LinkConnectionState.disconnected) return; + _backoff = minBackoff; + unawaited(_connect()); + } + + @override + void updateServer(LinkServerRecord server) { + if (_disposed) return; + final moved = + server.address != _server.address || + server.fingerprint != _server.fingerprint; + _server = server; + if (!moved) return; + _http?.close(force: true); + _http = null; + _dropSocket(1001); + _backoff = minBackoff; + if (_started && !_paused) unawaited(_connect()); + } + + /// Closes the socket and forgets pending connects and retries. + void _dropSocket(int code) { + _attempt++; + _retry?.cancel(); + _retry = null; + unawaited(_subscription?.cancel()); + _subscription = null; + final socket = _socket; + _socket = null; + unawaited(socket?.close(code).catchError((Object _) {})); + _setState(LinkConnectionState.disconnected); + } + + Future _connect() async { + if (_disposed || _paused || !_started) return; + if (_state != LinkConnectionState.disconnected) return; + _retry?.cancel(); + _retry = null; + final attempt = ++_attempt; + _setState(LinkConnectionState.connecting); + LinkSocket? socket; + try { + final origin = _origin; + await _ensureAccess(origin); + if (attempt != _attempt) return; + final uri = origin.replace( + scheme: origin.scheme == 'http' ? 'ws' : 'wss', + path: linkSocketPath, + ); + socket = await _connectSocket( + uri, + _authorization, + _client, + ).timeout(_handshakeTimeout); + if (attempt != _attempt) { + unawaited(socket.close(1001).catchError((Object _) {})); + return; + } + final opened = socket; + final welcome = Completer>(); + var welcomed = false; + _socket = opened; + _subscription = opened.stream.listen( + (data) { + final message = _decode(data); + if (message == null) return; + if (!welcomed) { + welcomed = true; + if (!welcome.isCompleted) welcome.complete(message); + return; + } + if (attempt == _attempt) _messages.add(message); + }, + onError: (Object error) { + if (!welcome.isCompleted) { + welcome.completeError(error); + } else { + _closed(attempt, opened); + } + }, + onDone: () { + if (!welcome.isCompleted) { + welcome.completeError( + opened.closeCode == linkCloseUnauthorized + ? const LinkException(LinkClientErrors.unauthorized) + : const SocketException('The computer closed the link'), + ); + } else { + _closed(attempt, opened); + } + }, + cancelOnError: true, + ); + opened.add( + jsonEncode({ + 'type': LinkMessageTypes.hello, + 'deviceId': _device.deviceId, + 'name': _device.name, + 'platform': _device.platform, + 'appVersion': _device.appVersion, + 'protocol': linkProtocolVersion, + }), + ); + final reply = await welcome.future.timeout(_handshakeTimeout); + if (attempt != _attempt) return; + final serverId = reply['serverId']; + if (reply['type'] != LinkMessageTypes.welcome || + reply['protocol'] != linkProtocolVersion || + (serverId is String && serverId != _server.serverId)) { + throw const LinkException('incompatible'); + } + _issue = null; + _backoff = minBackoff; + _setState(LinkConnectionState.connected); + } catch (error) { + if (attempt != _attempt || _disposed) { + if (socket != null && !identical(socket, _socket)) { + unawaited(socket.close(1001).catchError((Object _) {})); + } + return; + } + _issue = _issueFor(error); + _log.w('Connecting to the computer failed: ${_issue!.name}'); + _dropSocket(1000); + _scheduleRetry(); + } + } + + void _closed(int attempt, LinkSocket socket) { + if (attempt != _attempt || _disposed) return; + if (socket.closeCode == linkCloseUnauthorized) { + _issue = LinkSessionIssue.unauthorized; + } + _dropSocket(1000); + _scheduleRetry(); + } + + void _scheduleRetry() { + if (_disposed || _paused || !_started) return; + // A refused key or certificate will not fix itself quickly, and a + // denied permission waits for the person; retry slowly or not at all. + if (_issue == LinkSessionIssue.localNetworkPermission) return; + if (_issue == LinkSessionIssue.unauthorized || + _issue == LinkSessionIssue.certificate || + _issue == LinkSessionIssue.incompatible) { + _backoff = maxBackoff; + } + final delay = _backoff; + _backoff = Duration( + milliseconds: min(_backoff.inMilliseconds * 2, maxBackoff.inMilliseconds), + ); + _retry = _timer(delay, () { + _retry = null; + unawaited(_connect()); + }); + } + + static LinkSessionIssue _issueFor(Object error) => + switch (linkTransportException(error).code) { + LinkClientErrors.unauthorized => LinkSessionIssue.unauthorized, + LinkClientErrors.certificate => LinkSessionIssue.certificate, + LinkClientErrors.localNetworkPermission => + LinkSessionIssue.localNetworkPermission, + 'incompatible' => LinkSessionIssue.incompatible, + _ => LinkSessionIssue.unreachable, + }; + + static Map? _decode(Object? data) { + if (data is! String) return null; + try { + final decoded = jsonDecode(data); + if (decoded is Map && decoded['type'] is String) { + return decoded; + } + } on FormatException { + // Ignore frames that are not JSON objects. + } + return null; + } + + @override + void send(Map message) { + final socket = _socket; + if (_state != LinkConnectionState.connected || socket == null) return; + try { + socket.add(jsonEncode(message)); + } catch (error) { + _log.w('Sending to the computer failed: $error'); + } + } + + @override + Future get(String op, [Map query = const {}]) => + _request('GET', op, query: query); + + @override + Future post(String op, Map body) => + _request('POST', op, body: body); + + Future _request( + String method, + String op, { + Map query = const {}, + Map? body, + }) async { + if (_disposed) { + throw const LinkException( + LinkClientErrors.unavailable, + 'The link was closed', + ); + } + if (!_validOp(op)) { + throw LinkException(LinkClientErrors.invalid, 'Invalid operation $op'); + } + final origin = _origin; + final uri = origin.replace( + path: '$linkApiPath/$op', + queryParameters: query.isEmpty ? null : query, + ); + final LinkHttpResponse response; + try { + await _ensureAccess(origin); + response = await linkHttpSend( + _client, + method, + uri, + headers: _authorization, + json: method == 'GET' ? null : body, + timeout: _requestTimeout, + ); + } catch (error) { + throw linkTransportException(error); + } + if (response.ok) return response.body; + final failure = linkResponseException(response); + if (response.statusCode == 401) _issue = LinkSessionIssue.unauthorized; + throw failure; + } + + @override + Future dispose() async { + if (_disposed) return; + _dropSocket(1000); + _disposed = true; + _http?.close(force: true); + _http = null; + await _states.close(); + await _messages.close(); + } +} diff --git a/lib/services/link/client/link_client_store.dart b/lib/services/link/client/link_client_store.dart new file mode 100644 index 000000000..b2483284d --- /dev/null +++ b/lib/services/link/client/link_client_store.dart @@ -0,0 +1,125 @@ +import 'dart:convert'; +import 'dart:math'; + +import 'package:mornye/services/link/link_client_api.dart'; +import 'package:shared_preferences/shared_preferences.dart'; + +/// Paired desktops, the chosen one and this phone's device id, kept in +/// shared preferences. API keys stay in the network connection (secure +/// storage), never here. +class LinkClientStore { + LinkClientStore({ + Future Function()? preferences, + Random? random, + }) : _preferences = preferences ?? SharedPreferences.getInstance, + _random = random ?? Random.secure(); + + static const serversKey = 'link_client_servers'; + static const deviceIdKey = 'link_client_device_id'; + static const activeServerKey = 'link_client_active_server'; + + final Future Function() _preferences; + final Random _random; + Future _mutation = Future.value(); + + Future _mutate(Future Function() action) { + final result = _mutation.then((_) => action()); + _mutation = result.then((_) {}, onError: (Object _) {}); + return result; + } + + /// This phone's id towards every desktop: random, created once. + Future deviceId() => _mutate(() async { + final preferences = await _preferences(); + final existing = preferences.getString(deviceIdKey); + if (existing != null && existing.length >= 16) return existing; + final id = _uuid(); + await preferences.setString(deviceIdKey, id); + return id; + }); + + String _uuid() { + final bytes = List.generate(16, (_) => _random.nextInt(256)); + bytes[6] = (bytes[6] & 0x0f) | 0x40; + bytes[8] = (bytes[8] & 0x3f) | 0x80; + final hex = bytes.map((b) => b.toRadixString(16).padLeft(2, '0')).join(); + return '${hex.substring(0, 8)}-${hex.substring(8, 12)}-' + '${hex.substring(12, 16)}-${hex.substring(16, 20)}-${hex.substring(20)}'; + } + + Future> servers() async => _read(await _preferences()); + + List _read(SharedPreferences preferences) { + final raw = preferences.getString(serversKey); + if (raw == null) return const []; + try { + final decoded = jsonDecode(raw); + if (decoded is! List) return const []; + final seen = {}; + return List.unmodifiable([ + for (final row in decoded) + if (LinkServerRecord.fromJson(row) case final record? + when seen.add(record.serverId)) + record, + ]); + } on FormatException { + return const []; + } + } + + Future> _write( + List Function(List current) change, + ) => _mutate(() async { + final preferences = await _preferences(); + final next = List.unmodifiable( + change([..._read(preferences)]), + ); + await preferences.setString( + serversKey, + jsonEncode([for (final record in next) record.toJson()]), + ); + return next; + }); + + /// Adds [record], or replaces the record with its server id in place. + Future> upsert(LinkServerRecord record) => + _write((current) { + final index = current.indexWhere((r) => r.serverId == record.serverId); + if (index < 0) return current..add(record); + return current..[index] = record; + }); + + Future> remove(String serverId) => + _write((current) => current..removeWhere((r) => r.serverId == serverId)); + + /// Moves a paired desktop to [address] (`https://host:port`). + Future> updateAddress( + String serverId, + String address, + ) => _write( + (current) => [ + for (final record in current) + record.serverId == serverId + ? LinkServerRecord( + serverId: record.serverId, + name: record.name, + connectionId: record.connectionId, + address: address, + fingerprint: record.fingerprint, + ) + : record, + ], + ); + + Future activeServerId() async => + (await _preferences()).getString(activeServerKey); + + Future setActiveServerId(String? serverId) => _mutate(() async { + final preferences = await _preferences(); + if (serverId == null) { + await preferences.remove(activeServerKey); + } else { + await preferences.setString(activeServerKey, serverId); + } + }); +} diff --git a/macos/Flutter/GeneratedPluginRegistrant.swift b/macos/Flutter/GeneratedPluginRegistrant.swift index 468b01248..211df3fe6 100644 --- a/macos/Flutter/GeneratedPluginRegistrant.swift +++ b/macos/Flutter/GeneratedPluginRegistrant.swift @@ -9,6 +9,7 @@ import app_links import audio_service import audio_session import audioplayers_darwin +import bonsoir_darwin import connectivity_plus import dart_smb2 import desktop_drop @@ -30,6 +31,7 @@ func RegisterGeneratedPlugins(registry: FlutterPluginRegistry) { AudioServicePlugin.register(with: registry.registrar(forPlugin: "AudioServicePlugin")) AudioSessionPlugin.register(with: registry.registrar(forPlugin: "AudioSessionPlugin")) AudioplayersDarwinPlugin.register(with: registry.registrar(forPlugin: "AudioplayersDarwinPlugin")) + SwiftBonsoirPlugin.register(with: registry.registrar(forPlugin: "SwiftBonsoirPlugin")) ConnectivityPlusPlugin.register(with: registry.registrar(forPlugin: "ConnectivityPlusPlugin")) DartSmb2Plugin.register(with: registry.registrar(forPlugin: "DartSmb2Plugin")) DesktopDropPlugin.register(with: registry.registrar(forPlugin: "DesktopDropPlugin")) diff --git a/pubspec.lock b/pubspec.lock index f424a4c27..5ca60a037 100644 --- a/pubspec.lock +++ b/pubspec.lock @@ -190,6 +190,54 @@ packages: url: "https://pub.dev" source: hosted version: "4.4.1" + bonsoir: + dependency: "direct main" + description: + name: bonsoir + sha256: "20fed01e4616e625f4bafd9007ff899d231d8d79bebc8564853fa1e3570294a6" + url: "https://pub.dev" + source: hosted + version: "7.1.5" + bonsoir_android: + dependency: transitive + description: + name: bonsoir_android + sha256: "0dda1164e826553b8ee90a3fd1aabd462d17f19348f542b95f9d5b5455e4157f" + url: "https://pub.dev" + source: hosted + version: "7.1.3" + bonsoir_darwin: + dependency: transitive + description: + name: bonsoir_darwin + sha256: "6f695a0b4465514b75fc1a457746ab6dfc10d7180f0d04810fd9512e6520df69" + url: "https://pub.dev" + source: hosted + version: "7.1.1" + bonsoir_linux: + dependency: transitive + description: + name: bonsoir_linux + sha256: "9afae7bb9509c5bd20a0ea2ca02a0f2b1ef09cca1ceb2ea288ed58a0f03d1e11" + url: "https://pub.dev" + source: hosted + version: "7.1.0" + bonsoir_platform_interface: + dependency: transitive + description: + name: bonsoir_platform_interface + sha256: "6c55c786b01ad279f675ae72cea3a885aa746e416d2e8c1f0c46e9d2c06420b0" + url: "https://pub.dev" + source: hosted + version: "7.0.0" + bonsoir_windows: + dependency: transitive + description: + name: bonsoir_windows + sha256: aaabbb652fe68d3eb26a9b2cddefaae26cd9ca6ebe737d476ab9ed535c7c2516 + url: "https://pub.dev" + source: hosted + version: "7.3.0" boolean_selector: dependency: transitive description: diff --git a/pubspec.yaml b/pubspec.yaml index d7d8d2fc7..92de778fb 100644 --- a/pubspec.yaml +++ b/pubspec.yaml @@ -44,6 +44,8 @@ dependencies: # 7.3.2 requires dbus 0.8, while desktop_drop 0.8.4 still requires 0.7. connectivity_plus: ^7.3.1 crypto: ^3.0.7 + # Mornye Link: finds the desktop app on the local network (mDNS). + bonsoir: ^7.1.5 # Streaming backup archives archive: ^4.5.2 diff --git a/test/link_client_controller_test.dart b/test/link_client_controller_test.dart new file mode 100644 index 000000000..9bb3529fe --- /dev/null +++ b/test/link_client_controller_test.dart @@ -0,0 +1,364 @@ +import 'dart:convert'; + +import 'package:flutter/widgets.dart'; +import 'package:flutter_test/flutter_test.dart'; +import 'package:mornye/services/link/client/link_client_controller.dart'; +import 'package:mornye/services/link/client/link_client_discovery.dart'; +import 'package:mornye/services/link/client/link_client_pairing.dart'; +import 'package:mornye/services/link/client/link_client_session.dart'; +import 'package:mornye/services/link/client/link_client_store.dart'; +import 'package:mornye/services/link/link_client_api.dart'; +import 'package:mornye/services/link/link_protocol.dart'; +import 'package:mornye/services/local_network_access.dart'; +import 'package:mornye/services/network_storage_service.dart'; +import 'package:shared_preferences/shared_preferences.dart'; + +import 'support/link_client_fakes.dart'; + +Future _started({ + bool supported = true, + bool localNetworkAllowed = true, + bool onWifi = true, +}) async { + final harness = LinkClientHarness(supported: supported) + ..localNetworkAllowed = localNetworkAllowed + ..onWifi = onWifi; + addTearDown(harness.container.dispose); + await harness.start(); + await pumpEventQueue(); + return harness; +} + +Future _lifecycle(List states) async { + for (final state in states) { + TestWidgetsFlutterBinding.instance.handleAppLifecycleStateChanged(state); + } + await pumpEventQueue(); +} + +void main() { + TestWidgetsFlutterBinding.ensureInitialized(); + + setUp(() { + SharedPreferences.setMockInitialValues({}); + TestWidgetsFlutterBinding.instance.handleAppLifecycleStateChanged( + AppLifecycleState.resumed, + ); + }); + + test('pairing publishes the first desktop and follows the choice', () async { + final harness = await _started(); + expect(harness.state.loaded, isTrue); + expect(harness.state.activeServerId, isNull); + expect(harness.active, isNull); + + final a = await harness.controller.pair(linkTestTarget('a'), '123456'); + await pumpEventQueue(); + expect(harness.pairing.pins, ['123456']); + final device = harness.pairing.devices.single; + expect(device.name, 'Test phone'); + expect(device.platform, 'android'); + expect(device.deviceId, await LinkClientStore().deviceId()); + + final connection = harness.bridge.connections[a.connectionId]!; + expect(connection.protocol, NetworkProtocol.subsonic); + expect(connection.subsonicAuth, SubsonicAuth.apiKey); + expect(connection.apiKey, 'key-1'); + expect(connection.address, 'https://10.0.0.2:47710'); + expect(connection.name, 'Desktop a'); + expect(connection.trustedCertificateSha256, linkTestFingerprint('a')); + expect(harness.bridge.calls, [ + 'save ${a.connectionId}', + 'source ${a.connectionId}', + ]); + expect(harness.state.activeServerId, 'a'); + expect(harness.sessions, hasLength(1)); + final first = harness.sessions.single; + expect(harness.active, same(first)); + expect(first.apiKey, 'key-1'); + expect(first.calls, ['start']); + final stored = await LinkClientStore().servers(); + expect(stored.single.toJson(), a.toJson()); + + // A second desktop does not take over. + await harness.controller.pair( + linkTestTarget('b', host: '10.0.0.3'), + '654321', + ); + await pumpEventQueue(); + expect(harness.state.servers.map((s) => s.serverId), ['a', 'b']); + expect(harness.sessions, hasLength(1)); + expect(harness.active, same(first)); + + await harness.controller.setActive('b'); + await pumpEventQueue(); + expect(harness.sessions, hasLength(2)); + expect(first.disposed, isTrue); + expect(harness.active, same(harness.sessions.last)); + expect(harness.active!.server.serverId, 'b'); + expect(await LinkClientStore().activeServerId(), 'b'); + + final b = harness.state.activeServer!; + await harness.controller.forget('b', removeLibrary: true); + await pumpEventQueue(); + expect(harness.state.activeServerId, 'a'); + expect(harness.active!.server.serverId, 'a'); + expect(harness.sessions[1].disposed, isTrue); + expect(harness.bridge.calls.last, 'remove ${b.connectionId}'); + + await harness.controller.forget('a', removeLibrary: false); + await pumpEventQueue(); + expect(harness.state.servers, isEmpty); + expect(harness.active, isNull); + expect(harness.bridge.connections, contains(a.connectionId)); + expect(await LinkClientStore().servers(), isEmpty); + }); + + test('re-pairing replaces the key and keeps the connection', () async { + final harness = await _started(); + final first = await harness.controller.pair(linkTestTarget('a'), '111111'); + harness.pairing.key = 'key-2'; + final second = await harness.controller.pair( + linkTestTarget('a', host: '10.0.0.9'), + '222222', + ); + await pumpEventQueue(); + expect(second.connectionId, first.connectionId); + expect(harness.state.servers, hasLength(1)); + expect(harness.state.servers.single.address, 'https://10.0.0.9:47710'); + expect(harness.bridge.connections[first.connectionId]!.apiKey, 'key-2'); + expect(harness.sessions.last.apiKey, 'key-2'); + expect(harness.sessions.first.disposed, isTrue); + expect(harness.active, same(harness.sessions.last)); + }); + + test('a failed pairing saves nothing', () async { + final harness = await _started(); + harness.pairing.error = LinkPairingError.badPin; + await expectLater( + harness.controller.pair(linkTestTarget('a'), '000000'), + throwsA( + isA().having( + (e) => e.error, + 'error', + LinkPairingError.badPin, + ), + ), + ); + expect(harness.state.servers, isEmpty); + expect(harness.bridge.calls, isEmpty); + expect(harness.active, isNull); + }); + + test('a bad address fails before any request', () async { + final harness = await _started(); + await expectLater( + harness.controller.probe('host/path', 47710), + throwsA( + isA().having( + (e) => e.error, + 'error', + LinkPairingError.invalidAddress, + ), + ), + ); + expect(harness.pairing.probes, isEmpty); + }); + + test('stored desktops load with the saved active choice', () async { + final records = [ + for (final id in ['a', 'b']) + LinkServerRecord( + serverId: id, + name: 'Desktop $id', + connectionId: 'connection-$id', + address: 'https://10.0.0.2:47710', + fingerprint: linkTestFingerprint(id), + ), + ]; + SharedPreferences.setMockInitialValues({ + LinkClientStore.serversKey: jsonEncode([ + for (final record in records) record.toJson(), + ]), + LinkClientStore.activeServerKey: 'b', + }); + final harness = LinkClientHarness(); + addTearDown(harness.container.dispose); + harness.bridge.connections['connection-b'] = const NetworkConnection( + id: 'connection-b', + name: 'Desktop b', + protocol: NetworkProtocol.subsonic, + address: 'https://10.0.0.2:47710', + subsonicAuth: SubsonicAuth.apiKey, + apiKey: 'stored-key', + ); + await harness.start(); + await pumpEventQueue(); + expect(harness.state.servers, hasLength(2)); + expect(harness.state.activeServerId, 'b'); + expect(harness.sessions.single.apiKey, 'stored-key'); + expect(harness.active, same(harness.sessions.single)); + + // A desktop whose connection was removed elsewhere must pair again. + await harness.controller.setActive('a'); + await pumpEventQueue(); + expect(harness.active, isNull); + expect(harness.state.issue, LinkSessionIssue.unauthorized); + }); + + test('state follows the session and discovery follows the desktop', () async { + final harness = await _started(); + final record = await harness.controller.pair(linkTestTarget('a'), '123456'); + await pumpEventQueue(); + final session = harness.sessions.single; + + // Disconnected: discovery looks for the desktop. + expect(harness.browser.started, 1); + expect(harness.state.discovery, LinkDiscoveryStatus.searching); + + session.emit(LinkConnectionState.connected); + await pumpEventQueue(); + expect(harness.state.connection, LinkConnectionState.connected); + expect(harness.browser.stopped, 1); + + session.emit( + LinkConnectionState.disconnected, + LinkSessionIssue.unreachable, + ); + await pumpEventQueue(); + expect(harness.state.issue, LinkSessionIssue.unreachable); + expect(harness.browser.started, 2); + + // Seen again at the same address: reconnect at once. + harness.browser.resolve('a', '10.0.0.2'); + await pumpEventQueue(); + expect(session.calls.last, 'reconnect'); + + // Seen at a new address: the record, connection and session move. + harness.browser.resolve('a', '10.0.0.7'); + await pumpEventQueue(); + expect(harness.state.servers.single.address, 'https://10.0.0.7:47710'); + expect( + (await LinkClientStore().servers()).single.address, + 'https://10.0.0.7:47710', + ); + expect( + harness.bridge.calls.last, + 'address ${record.connectionId} https://10.0.0.7:47710', + ); + expect(session.calls.last, 'update https://10.0.0.7:47710'); + }); + + test('another certificate under a known id is not followed', () async { + final harness = await _started(); + await harness.controller.pair(linkTestTarget('a'), '123456'); + await pumpEventQueue(); + final session = harness.sessions.single; + harness.browser.resolve('a', '10.0.0.66', fingerprint: 'cc' * 32); + await pumpEventQueue(); + expect(harness.state.servers.single.address, 'https://10.0.0.2:47710'); + expect(session.calls, ['start']); + expect( + harness.state.certificateChanged(harness.state.activeServer!), + isTrue, + ); + }); + + test('the session pauses in the background and resumes after', () async { + final harness = await _started(); + await harness.controller.pair(linkTestTarget('a'), '123456'); + await pumpEventQueue(); + final session = harness.sessions.single; + + await _lifecycle([AppLifecycleState.inactive]); + expect(session.calls, ['start']); + + await _lifecycle([AppLifecycleState.hidden, AppLifecycleState.paused]); + expect(session.calls, ['start', 'pause']); + expect(harness.browser.stopped, 1); + + await _lifecycle([ + AppLifecycleState.hidden, + AppLifecycleState.inactive, + AppLifecycleState.resumed, + ]); + expect(session.calls, ['start', 'pause', 'resume']); + expect(harness.browser.started, 2); + }); + + test('catalog.changed rescans the desktop once bursts settle', () async { + final harness = await _started(); + final record = await harness.controller.pair(linkTestTarget('a'), '123456'); + await pumpEventQueue(); + final session = harness.sessions.single; + session.push({'type': LinkMessageTypes.catalogChanged, 'version': 1}); + session.push({'type': 'player.state'}); + session.push({'type': LinkMessageTypes.catalogChanged, 'version': 2}); + await pumpEventQueue(); + expect(harness.bridge.calls.where((c) => c.startsWith('rescan')), isEmpty); + await Future.delayed( + LinkClientController.rescanDelay + const Duration(milliseconds: 200), + ); + expect(harness.bridge.calls.where((c) => c.startsWith('rescan')), [ + 'rescan ${record.connectionId}', + ]); + }); + + test('a refused permission stops discovery until asked again', () async { + final harness = await _started(localNetworkAllowed: false); + final release = harness.controller.acquireDiscovery(); + addTearDown(release); + await pumpEventQueue(); + expect(harness.state.discovery, LinkDiscoveryStatus.permissionDenied); + expect(harness.browser.started, 0); + + await expectLater( + harness.controller.requestLocalNetworkAccess(), + throwsA(isA()), + ); + harness.localNetworkAllowed = true; + await harness.controller.requestLocalNetworkAccess(); + await pumpEventQueue(); + expect(harness.state.discovery, LinkDiscoveryStatus.searching); + expect(harness.browser.started, 1); + + harness.browser.resolve('b', '10.0.0.3'); + await pumpEventQueue(); + expect(harness.state.unpaired.single.serverId, 'b'); + + release(); + await pumpEventQueue(); + expect(harness.state.discovery, LinkDiscoveryStatus.idle); + expect(harness.state.discovered, isEmpty); + }); + + test('the page hears when Wi-Fi is off', () async { + final harness = await _started(onWifi: false); + harness.controller.acquireDiscovery()(); + await pumpEventQueue(); + expect(harness.state.localNetworkAvailable, isFalse); + }); + + test('disposing closes the session and discovery', () async { + final harness = LinkClientHarness(); + await harness.start(); + await harness.controller.pair(linkTestTarget('a'), '123456'); + await pumpEventQueue(); + harness.container.dispose(); + await pumpEventQueue(); + expect(harness.sessions.single.disposed, isTrue); + expect(harness.browser.stopped, 1); + }); + + test('unsupported platforms stay inert', () async { + final harness = await _started(supported: false); + expect(harness.state.loaded, isTrue); + harness.controller.acquireDiscovery(); + await harness.controller.requestLocalNetworkAccess(); + await pumpEventQueue(); + expect(harness.browser.started, 0); + expect(harness.active, isNull); + final preferences = await SharedPreferences.getInstance(); + expect(preferences.getKeys(), isEmpty); + }); +} diff --git a/test/link_client_discovery_test.dart b/test/link_client_discovery_test.dart new file mode 100644 index 000000000..54840ff4e --- /dev/null +++ b/test/link_client_discovery_test.dart @@ -0,0 +1,188 @@ +import 'dart:async'; + +import 'package:flutter_test/flutter_test.dart'; +import 'package:mornye/services/link/client/link_client_discovery.dart'; +import 'package:mornye/services/local_network_access.dart'; + +final _fp = 'ab' * 32; + +LinkServiceResolved _service({ + String name = 'Studio PC', + int port = 47710, + List addresses = const ['192.168.1.20'], + String? hostname, + Map? attributes, +}) => LinkServiceResolved( + name: name, + port: port, + addresses: addresses, + hostname: hostname, + attributes: attributes ?? {'v': '1', 'id': 'server-1', 'fp': _fp}, +); + +class _FakeBrowser implements LinkServiceBrowser { + _FakeBrowser() { + // Stays open across stop() so late events can be checked. Not awaited: + // a stream nobody listened to never reports done. + addTearDown(() => unawaited(events.close())); + } + + final events = StreamController(); + int started = 0; + int stopped = 0; + + @override + Future> start() async { + started++; + return events.stream; + } + + @override + Future stop() async => stopped++; +} + +void main() { + group('service mapping', () { + test('reads id, fingerprint, host and port from the record', () { + final server = linkDiscoveredServerFrom( + _service( + attributes: {'v': '1', 'id': ' server-1 ', 'fp': _fp.toUpperCase()}, + ), + )!; + expect(server.serverId, 'server-1'); + expect(server.fingerprint, _fp); + expect(server.name, 'Studio PC'); + expect(server.address, 'https://192.168.1.20:47710'); + }); + + test('ignores services of another version or without identity', () { + for (final attributes in [ + {'v': '2', 'id': 'server-1', 'fp': _fp}, + {'id': 'server-1', 'fp': _fp}, + {'v': '1', 'fp': _fp}, + {'v': '1', 'id': 'server-1', 'fp': 'not-hex'}, + {'v': '1', 'id': 'server-1'}, + ]) { + expect( + linkDiscoveredServerFrom(_service(attributes: attributes)), + isNull, + reason: '$attributes', + ); + } + expect(linkDiscoveredServerFrom(_service(port: 0)), isNull); + expect(linkDiscoveredServerFrom(_service(addresses: const [])), isNull); + }); + + test('prefers IPv4, then routable IPv6, then the host name', () { + expect( + linkPreferredHost(['fe80::1%wlan0', '2001:db8::5', '10.0.0.4'], null), + '10.0.0.4', + ); + expect( + linkPreferredHost(['fe80::1', '2001:db8::5'], null), + '2001:db8::5', + ); + expect(linkPreferredHost(['fe80::1'], 'studio.local.'), 'studio.local'); + expect(linkPreferredHost(['127.0.0.1'], null), isNull); + expect( + linkDiscoveredServerFrom( + _service(addresses: const ['2001:db8::5']), + )!.address, + 'https://[2001:db8::5]:47710', + ); + }); + }); + + group('LinkDiscovery', () { + test('tracks resolved and lost desktops', () async { + final browser = _FakeBrowser(); + var changes = 0; + final discovery = LinkDiscovery( + createBrowser: () => browser, + ensureAccess: () async {}, + onChanged: () => changes++, + ); + await discovery.start(); + expect(discovery.status, LinkDiscoveryStatus.searching); + expect(browser.started, 1); + + browser.events.add(_service()); + browser.events.add( + _service( + name: 'Laptop', + addresses: const ['192.168.1.30'], + attributes: {'v': '1', 'id': 'server-2', 'fp': 'cd' * 32}, + ), + ); + await pumpEventQueue(); + expect(discovery.servers.map((s) => s.name), ['Laptop', 'Studio PC']); + + // An update without addresses keeps the resolved entry. + final before = changes; + browser.events.add(_service(addresses: const [])); + await pumpEventQueue(); + expect(changes, before); + expect(discovery.servers, hasLength(2)); + + // A move to another address replaces the entry. + browser.events.add(_service(addresses: const ['192.168.1.21'])); + await pumpEventQueue(); + expect( + discovery.servers.firstWhere((s) => s.serverId == 'server-1').host, + '192.168.1.21', + ); + + browser.events.add(const LinkServiceLost('Laptop')); + await pumpEventQueue(); + expect(discovery.servers.map((s) => s.serverId), ['server-1']); + + await discovery.stop(); + expect(discovery.status, LinkDiscoveryStatus.idle); + expect(discovery.servers, isEmpty); + expect(browser.stopped, 1); + }); + + test('events after stop are ignored', () async { + final browser = _FakeBrowser(); + final discovery = LinkDiscovery( + createBrowser: () => browser, + ensureAccess: () async {}, + onChanged: () {}, + ); + await discovery.start(); + await discovery.stop(); + browser.events.add(_service()); + await pumpEventQueue(); + expect(discovery.servers, isEmpty); + }); + + test('a refused permission is reported, not retried', () async { + final browser = _FakeBrowser(); + final discovery = LinkDiscovery( + createBrowser: () => browser, + ensureAccess: () async => throw const LocalNetworkPermissionException(), + onChanged: () {}, + ); + await discovery.start(); + expect(discovery.status, LinkDiscoveryStatus.permissionDenied); + expect(discovery.running, isFalse); + expect(browser.started, 0); + }); + + test('a browser error stops discovery', () async { + final browser = _FakeBrowser(); + final discovery = LinkDiscovery( + createBrowser: () => browser, + ensureAccess: () async {}, + onChanged: () {}, + ); + await discovery.start(); + browser.events.add(_service()); + browser.events.addError(StateError('nsd failed')); + await pumpEventQueue(); + expect(discovery.status, LinkDiscoveryStatus.failed); + expect(discovery.servers, isEmpty); + expect(browser.stopped, 1); + }); + }); +} diff --git a/test/link_client_pairing_test.dart b/test/link_client_pairing_test.dart new file mode 100644 index 000000000..0ad596584 --- /dev/null +++ b/test/link_client_pairing_test.dart @@ -0,0 +1,354 @@ +import 'dart:convert'; +import 'dart:io'; + +import 'package:crypto/crypto.dart'; +import 'package:flutter_test/flutter_test.dart'; +import 'package:mornye/services/link/client/link_client_http.dart'; +import 'package:mornye/services/link/client/link_client_pairing.dart'; +import 'package:mornye/services/link/link_protocol.dart'; + +const _device = LinkDeviceIdentity( + deviceId: 'phone-1', + name: 'Test phone', + platform: 'android', + appVersion: '1.0.0', +); + +/// SHA-256 of the fixture certificate's DER bytes. +String _fixtureFingerprint() { + final pem = File('test/fixtures/network_tls/cert.pem').readAsStringSync(); + final base64Body = pem + .split('\n') + .where((line) => line.isNotEmpty && !line.startsWith('-----')) + .join(); + return sha256.convert(base64.decode(base64Body)).toString(); +} + +/// A desktop over TLS with the fixture certificate. [claimedFingerprint] +/// is what `info` reports; [onPair] answers `POST pair`. +Future _desktop({ + required String claimedFingerprint, + bool pairing = true, + int protocol = linkProtocolVersion, + Future Function(HttpRequest request, Map body)? onPair, +}) async { + final context = SecurityContext() + ..useCertificateChain('test/fixtures/network_tls/cert.pem') + ..usePrivateKey('test/fixtures/network_tls/key.pem'); + final server = await HttpServer.bindSecure( + InternetAddress.loopbackIPv4, + 0, + context, + ); + server.listen((request) async { + final response = request.response; + response.headers.contentType = ContentType.json; + if (request.uri.path == '/mornye/v1/info') { + response.write( + jsonEncode({ + 'serverId': 'server-1', + 'name': 'Studio PC', + 'protocol': protocol, + 'appVersion': '5.3.0', + 'fingerprint': claimedFingerprint, + 'pairing': pairing, + }), + ); + } else if (request.uri.path == '/mornye/v1/pair' && + request.method == 'POST') { + final body = + jsonDecode(await utf8.decoder.bind(request).join()) + as Map; + await onPair?.call(request, body); + } else { + response.statusCode = 404; + } + await response.close(); + }, onError: (Object _) {}); + return server; +} + +void main() { + // TLS needs real sockets. + HttpOverrides.global = null; + final fingerprint = _fixtureFingerprint(); + + group('pinned client', () { + late HttpServer server; + + setUp(() async { + server = await _desktop(claimedFingerprint: fingerprint); + }); + tearDown(() => server.close(force: true)); + + Uri info() => Uri.parse('https://127.0.0.1:${server.port}/mornye/v1/info'); + + test('accepts exactly the pinned certificate', () async { + final client = linkPinnedHttpClient(fingerprint.toUpperCase()); + addTearDown(() => client.close(force: true)); + final response = await linkHttpSend(client, 'GET', info()); + expect(response.statusCode, 200); + expect(response.certificateFingerprint, fingerprint); + }); + + test('refuses any other certificate during the handshake', () async { + final client = linkPinnedHttpClient('0' * 64); + addTearDown(() => client.close(force: true)); + await expectLater( + linkHttpSend(client, 'GET', info()), + throwsA(isA()), + ); + }); + + test('first contact accepts only the target and records it', () async { + final target = Uri.parse('https://127.0.0.1:${server.port}'); + final client = linkFirstContactHttpClient(target); + addTearDown(() => client.close(force: true)); + final response = await linkHttpSend(client, 'GET', info()); + expect(response.certificateFingerprint, fingerprint); + + final other = linkFirstContactHttpClient( + Uri.parse('https://127.0.0.1:${server.port + 1}'), + ); + addTearDown(() => other.close(force: true)); + await expectLater( + linkHttpSend(other, 'GET', info()), + throwsA(isA()), + ); + }); + }); + + group('pairing', () { + test('pairs with a proof over the observed fingerprint', () async { + Map? sent; + final server = await _desktop( + claimedFingerprint: fingerprint, + onPair: (request, body) async { + sent = body; + request.response.write( + jsonEncode({ + 'apiKey': 'key-1', + 'serverId': 'server-1', + 'name': 'Studio PC', + 'fingerprint': fingerprint, + }), + ); + }, + ); + addTearDown(() => server.close(force: true)); + final client = LinkPairingClient(); + final target = await client.probe( + Uri.parse('https://127.0.0.1:${server.port}'), + expectedFingerprint: fingerprint, + ); + expect(target.address, 'https://127.0.0.1:${server.port}'); + expect(target.info.serverId, 'server-1'); + expect(target.info.pairing, isTrue); + expect(target.shortFingerprint, fingerprint.substring(0, 8)); + + final result = await client.pair(target, pin: '123456', device: _device); + expect(result.apiKey, 'key-1'); + expect(result.serverId, 'server-1'); + expect(result.name, 'Studio PC'); + expect(result.fingerprint, fingerprint); + expect(sent, { + 'deviceId': 'phone-1', + 'name': 'Test phone', + 'platform': 'android', + 'proof': linkPairingProof( + pin: '123456', + fingerprint: fingerprint, + deviceId: 'phone-1', + ), + }); + }); + + test('aborts when info claims another certificate', () async { + final server = await _desktop(claimedFingerprint: 'a' * 64); + addTearDown(() => server.close(force: true)); + await expectLater( + LinkPairingClient().probe( + Uri.parse('https://127.0.0.1:${server.port}'), + ), + throwsA( + isA().having( + (e) => e.error, + 'error', + LinkPairingError.certificateMismatch, + ), + ), + ); + }); + + test('aborts when mDNS advertised another certificate', () async { + final server = await _desktop(claimedFingerprint: fingerprint); + addTearDown(() => server.close(force: true)); + await expectLater( + LinkPairingClient().probe( + Uri.parse('https://127.0.0.1:${server.port}'), + expectedFingerprint: 'b' * 64, + ), + throwsA( + isA().having( + (e) => e.error, + 'error', + LinkPairingError.certificateMismatch, + ), + ), + ); + }); + + test('refuses another protocol version', () async { + final server = await _desktop( + claimedFingerprint: fingerprint, + protocol: 2, + ); + addTearDown(() => server.close(force: true)); + await expectLater( + LinkPairingClient().probe( + Uri.parse('https://127.0.0.1:${server.port}'), + ), + throwsA( + isA().having( + (e) => e.error, + 'error', + LinkPairingError.incompatible, + ), + ), + ); + }); + + for (final (status, body, expected) in [ + (403, {'error': 'bad_proof'}, LinkPairingError.badPin), + (403, {'error': 'pairing_closed'}, LinkPairingError.pairingClosed), + (429, {'error': 'rate_limited'}, LinkPairingError.tooManyAttempts), + (500, {'error': 'internal'}, LinkPairingError.failed), + ]) { + test('maps $status ${body['error']} to ${expected.name}', () async { + final server = await _desktop( + claimedFingerprint: fingerprint, + onPair: (request, _) async { + request.response.statusCode = status; + request.response.write(jsonEncode(body)); + }, + ); + addTearDown(() => server.close(force: true)); + final client = LinkPairingClient(); + final target = await client.probe( + Uri.parse('https://127.0.0.1:${server.port}'), + ); + await expectLater( + client.pair(target, pin: '000000', device: _device), + throwsA( + isA().having( + (e) => e.error, + 'error', + expected, + ), + ), + ); + }); + } + + test('a certificate swapped after info stops the pairing', () async { + final server = await _desktop(claimedFingerprint: fingerprint); + addTearDown(() => server.close(force: true)); + final target = LinkPairingTarget( + address: 'https://127.0.0.1:${server.port}', + info: LinkServerInfo( + serverId: 'server-1', + name: 'Studio PC', + protocol: linkProtocolVersion, + appVersion: '5.3.0', + fingerprint: 'c' * 64, + pairing: true, + ), + ); + await expectLater( + LinkPairingClient().pair(target, pin: '123456', device: _device), + throwsA( + isA().having( + (e) => e.error, + 'error', + LinkPairingError.certificateMismatch, + ), + ), + ); + }); + + test('rejects a PIN that is not six digits without a request', () async { + final target = LinkPairingTarget( + address: 'https://127.0.0.1:1', + info: LinkServerInfo( + serverId: 'server-1', + name: 'Studio PC', + protocol: linkProtocolVersion, + appVersion: '5.3.0', + fingerprint: fingerprint, + pairing: true, + ), + ); + await expectLater( + LinkPairingClient().pair(target, pin: '12a456', device: _device), + throwsA( + isA().having( + (e) => e.error, + 'error', + LinkPairingError.badPin, + ), + ), + ); + }); + + test('an unreachable computer is reported as such', () async { + final socket = await ServerSocket.bind(InternetAddress.loopbackIPv4, 0); + final port = socket.port; + await socket.close(); + await expectLater( + LinkPairingClient().probe(Uri.parse('https://127.0.0.1:$port')), + throwsA( + isA().having( + (e) => e.error, + 'error', + LinkPairingError.unreachable, + ), + ), + ); + }); + }); + + group('fingerprint checks', () { + test('need an observed certificate equal to every claim', () { + expect( + linkFingerprintsMatch(observed: 'ab', claimed: 'AB', advertised: 'ab'), + isTrue, + ); + expect(linkFingerprintsMatch(observed: null, claimed: 'ab'), isFalse); + expect(linkFingerprintsMatch(observed: 'ab', claimed: 'cd'), isFalse); + expect( + linkFingerprintsMatch(observed: 'ab', claimed: 'ab', advertised: 'cd'), + isFalse, + ); + }); + + test('server addresses accept hosts and refuse URLs', () { + expect( + linkServerAddress('192.168.1.20', 47710).toString(), + 'https://192.168.1.20:47710', + ); + expect( + linkServerAddress('fe80::2', 47710).toString(), + 'https://[fe80::2]:47710', + ); + expect( + linkServerAddress('[2001:db8::1]', 1).toString(), + 'https://[2001:db8::1]:1', + ); + expect(linkServerAddress('', 47710), isNull); + expect(linkServerAddress('host/path', 47710), isNull); + expect(linkServerAddress('host:1', 47710), isNull); + expect(linkServerAddress('host', 0), isNull); + expect(linkServerAddress('host', 70000), isNull); + }); + }); +} diff --git a/test/link_client_session_test.dart b/test/link_client_session_test.dart new file mode 100644 index 000000000..8cba5f0af --- /dev/null +++ b/test/link_client_session_test.dart @@ -0,0 +1,564 @@ +import 'dart:async'; +import 'dart:convert'; +import 'dart:io'; + +import 'package:flutter_test/flutter_test.dart'; +import 'package:mornye/services/link/client/link_client_pairing.dart'; +import 'package:mornye/services/link/client/link_client_session.dart'; +import 'package:mornye/services/link/link_client_api.dart'; +import 'package:mornye/services/link/link_protocol.dart'; + +const _device = LinkDeviceIdentity( + deviceId: 'phone-1', + name: 'Test phone', + platform: 'ios', + appVersion: '5.3.0', +); + +LinkServerRecord _record(String address) => LinkServerRecord( + serverId: 'server-1', + name: 'Studio PC', + connectionId: 'connection-1', + address: address, + fingerprint: 'f' * 64, +); + +const _welcome = { + 'type': 'welcome', + 'serverId': 'server-1', + 'name': 'Studio PC', + 'protocol': 1, +}; + +class _FakeTimer implements Timer { + _FakeTimer(this._run); + + final void Function() _run; + var _active = true; + + @override + bool get isActive => _active; + + @override + int get tick => 0; + + @override + void cancel() => _active = false; + + void fire() { + if (!_active) return; + _active = false; + _run(); + } +} + +/// Records requested delays; tests fire retries by hand. +class _Timers { + final delays = []; + final timers = <_FakeTimer>[]; + + Timer call(Duration delay, void Function() run) { + delays.add(delay); + final timer = _FakeTimer(run); + timers.add(timer); + return timer; + } + + _FakeTimer get last => timers.last; +} + +class _FakeSocket implements LinkSocket { + _FakeSocket({this.welcome = _welcome, this.closeBeforeWelcome}); + + final Map? welcome; + final int? closeBeforeWelcome; + final incoming = StreamController(); + final sent = >[]; + int? _closeCode; + bool closed = false; + + @override + Stream get stream => incoming.stream; + + @override + int? get closeCode => _closeCode; + + @override + void add(String data) { + final message = jsonDecode(data) as Map; + sent.add(message); + if (message['type'] != 'hello') return; + scheduleMicrotask(() { + if (closeBeforeWelcome case final code?) { + serverClose(code); + } else if (welcome case final reply?) { + incoming.add(jsonEncode(reply)); + } + }); + } + + void push(Map message) => incoming.add(jsonEncode(message)); + + void serverClose([int code = 1001]) { + _closeCode = code; + unawaited(incoming.close()); + } + + @override + Future close([int? code, String? reason]) async { + closed = true; + _closeCode ??= code; + unawaited(incoming.close()); + } +} + +void main() { + group('requests', () { + late HttpServer server; + late LinkClientSession session; + final requests = []; + final bodies = []; + + setUp(() async { + requests.clear(); + bodies.clear(); + server = await HttpServer.bind(InternetAddress.loopbackIPv4, 0); + server.listen((request) async { + requests.add(request); + bodies.add(await utf8.decoder.bind(request).join()); + final response = request.response; + switch (request.uri.path) { + case '/mornye/v1/state': + response.headers.contentType = ContentType.json; + response.write(jsonEncode({'playing': true})); + case '/mornye/v1/handoff/play': + response.headers.contentType = ContentType.json; + response.write(jsonEncode({'resolved': 2, 'missing': []})); + case '/mornye/v1/open': + response.statusCode = 204; + case '/mornye/v1/secret': + response.statusCode = 401; + default: + response.statusCode = 404; + response.headers.contentType = ContentType.json; + response.write( + jsonEncode({'error': 'not_found', 'message': 'No handler'}), + ); + } + await response.close(); + }); + session = LinkClientSession( + server: _record('http://127.0.0.1:${server.port}'), + apiKey: 'key-1', + device: _device, + httpClient: (_) => HttpClient(), + ensureAccess: (_) async {}, + ); + }); + + tearDown(() async { + await session.dispose(); + await server.close(force: true); + }); + + test('GET sends the bearer key and query, and decodes JSON', () async { + final result = await session.get(LinkOps.state, {'since': '5'}); + expect(result, {'playing': true}); + final request = requests.single; + expect(request.method, 'GET'); + expect(request.uri.path, '/mornye/v1/state'); + expect(request.uri.queryParameters, {'since': '5'}); + expect(request.headers.value('authorization'), 'Bearer key-1'); + expect(request.headers.value('accept'), 'application/json'); + }); + + test('POST sends a JSON body to a nested op', () async { + final result = await session.post(LinkOps.handoffPlay, { + 'index': 1, + 'queue': [], + }); + expect(result, {'resolved': 2, 'missing': []}); + expect(requests.single.method, 'POST'); + expect(requests.single.headers.contentType?.mimeType, 'application/json'); + expect(jsonDecode(bodies.single), {'index': 1, 'queue': []}); + }); + + test('an empty success answers null', () async { + expect(await session.post(LinkOps.open, {'url': 'x'}), isNull); + }); + + test('error bodies become LinkException', () async { + await expectLater( + session.get('missing'), + throwsA( + isA() + .having((e) => e.code, 'code', 'not_found') + .having((e) => e.message, 'message', 'No handler'), + ), + ); + }); + + test('a bare 401 is unauthorized and marks the session', () async { + await expectLater( + session.get('secret'), + throwsA( + isA().having((e) => e.code, 'code', 'unauthorized'), + ), + ); + expect(session.issue, LinkSessionIssue.unauthorized); + }); + + test('operations outside the API path are refused locally', () async { + for (final op in [ + '../rest/ping', + 'library/../../rest', + './state', + '/state', + 'a//b', + 'state?x=1', + '', + ]) { + await expectLater( + session.get(op), + throwsA( + isA().having((e) => e.code, 'code', 'invalid'), + ), + ); + } + expect(requests, isEmpty); + }); + + test('an unreachable desktop is unavailable', () async { + final port = server.port; + await server.close(force: true); + final offline = LinkClientSession( + server: _record('http://127.0.0.1:$port'), + apiKey: 'key-1', + device: _device, + httpClient: (_) => HttpClient(), + ensureAccess: (_) async {}, + ); + addTearDown(offline.dispose); + await expectLater( + offline.get(LinkOps.state), + throwsA( + isA().having((e) => e.code, 'code', 'unavailable'), + ), + ); + }); + }); + + group('WebSocket', () { + test('says hello, waits for welcome and relays messages', () async { + final server = await HttpServer.bind(InternetAddress.loopbackIPv4, 0); + addTearDown(() => server.close(force: true)); + final hello = Completer>(); + final fromPhone = StreamController>(); + addTearDown(fromPhone.close); + WebSocket? desktop; + String? authorization; + server.listen((request) async { + authorization = request.headers.value('authorization'); + desktop = await WebSocketTransformer.upgrade(request); + desktop!.listen((data) { + final message = jsonDecode(data as String) as Map; + if (!hello.isCompleted) { + hello.complete(message); + desktop!.add(jsonEncode(_welcome)); + } else { + fromPhone.add(message); + } + }); + }); + final timers = _Timers(); + final session = LinkClientSession( + server: _record('http://127.0.0.1:${server.port}'), + apiKey: 'key-1', + device: _device, + httpClient: (_) => HttpClient(), + ensureAccess: (_) async {}, + timer: timers.call, + ); + addTearDown(session.dispose); + final states = []; + session.connectionStates.listen(states.add); + final messages = >[]; + session.messages.listen(messages.add); + + session.start(); + await session.connectionStates + .firstWhere((s) => s == LinkConnectionState.connected) + .timeout(const Duration(seconds: 5)); + expect(authorization, 'Bearer key-1'); + expect(await hello.future, { + 'type': 'hello', + 'deviceId': 'phone-1', + 'name': 'Test phone', + 'platform': 'ios', + 'appVersion': '5.3.0', + 'protocol': 1, + }); + expect(states, [ + LinkConnectionState.connecting, + LinkConnectionState.connected, + ]); + + desktop!.add(jsonEncode({'type': 'catalog.changed', 'version': 2})); + desktop!.add('not json'); + desktop!.add(jsonEncode([1, 2])); + session.send({'type': 'player.state', 'state': {}}); + expect(await fromPhone.stream.first.timeout(const Duration(seconds: 5)), { + 'type': 'player.state', + 'state': {}, + }); + await pumpEventQueue(); + expect(messages, [ + {'type': 'catalog.changed', 'version': 2}, + ]); + + // The desktop going away schedules a retry after the shortest delay. + await desktop!.close(); + await session.connectionStates + .firstWhere((s) => s == LinkConnectionState.disconnected) + .timeout(const Duration(seconds: 5)); + await pumpEventQueue(); + expect(timers.delays, [LinkClientSession.minBackoff]); + }); + + test('backs off from 1 s doubling to 30 s, then resets', () async { + final timers = _Timers(); + var failures = 6; + final connects = []; + final session = LinkClientSession( + server: _record('https://10.0.0.2:47710'), + apiKey: 'key-1', + device: _device, + ensureAccess: (_) async {}, + timer: timers.call, + connectSocket: (uri, headers, client) async { + connects.add(uri); + expect( + headers['authorization'] ?? headers['Authorization'], + 'Bearer key-1', + ); + if (failures-- > 0) throw const SocketException('offline'); + return _FakeSocket(); + }, + ); + addTearDown(session.dispose); + session.start(); + await pumpEventQueue(); + for (var i = 0; i < 6; i++) { + expect(session.connectionState, LinkConnectionState.disconnected); + expect(session.issue, LinkSessionIssue.unreachable); + timers.last.fire(); + await pumpEventQueue(); + } + expect(timers.delays, const [ + Duration(seconds: 1), + Duration(seconds: 2), + Duration(seconds: 4), + Duration(seconds: 8), + Duration(seconds: 16), + Duration(seconds: 30), + ]); + expect(session.connectionState, LinkConnectionState.connected); + expect(session.issue, isNull); + expect(connects.first.toString(), 'wss://10.0.0.2:47710/mornye/v1/ws'); + expect(connects, hasLength(7)); + }); + + test('a dropped link retries after 1 s again', () async { + final timers = _Timers(); + final sockets = <_FakeSocket>[]; + final session = LinkClientSession( + server: _record('https://10.0.0.2:47710'), + apiKey: 'key-1', + device: _device, + ensureAccess: (_) async {}, + timer: timers.call, + connectSocket: (_, _, _) async { + final socket = _FakeSocket(); + sockets.add(socket); + return socket; + }, + ); + addTearDown(session.dispose); + session.start(); + await pumpEventQueue(); + expect(session.connectionState, LinkConnectionState.connected); + sockets.last.push({'type': 'open', 'url': 'x'}); + sockets.last.serverClose(); + await pumpEventQueue(); + expect(session.connectionState, LinkConnectionState.disconnected); + expect(timers.delays, [LinkClientSession.minBackoff]); + timers.last.fire(); + await pumpEventQueue(); + expect(session.connectionState, LinkConnectionState.connected); + expect(sockets, hasLength(2)); + }); + + test('pause closes the link and resume reconnects at once', () async { + final timers = _Timers(); + final sockets = <_FakeSocket>[]; + final session = LinkClientSession( + server: _record('https://10.0.0.2:47710'), + apiKey: 'key-1', + device: _device, + ensureAccess: (_) async {}, + timer: timers.call, + connectSocket: (_, _, _) async { + final socket = _FakeSocket(); + sockets.add(socket); + return socket; + }, + ); + addTearDown(session.dispose); + session.start(); + await pumpEventQueue(); + session.pause(); + await pumpEventQueue(); + expect(sockets.single.closed, isTrue); + expect(session.connectionState, LinkConnectionState.disconnected); + expect(timers.delays, isEmpty); + session.send({'type': 'player.state'}); + session.reconnectNow(); + await pumpEventQueue(); + expect(sockets, hasLength(1)); + + session.resume(); + await pumpEventQueue(); + expect(session.connectionState, LinkConnectionState.connected); + expect(sockets, hasLength(2)); + expect(sockets.first.sent.map((m) => m['type']), ['hello']); + }); + + test('reconnectNow skips the remaining backoff', () async { + final timers = _Timers(); + var online = false; + final session = LinkClientSession( + server: _record('https://10.0.0.2:47710'), + apiKey: 'key-1', + device: _device, + ensureAccess: (_) async {}, + timer: timers.call, + connectSocket: (_, _, _) async { + if (!online) throw const SocketException('offline'); + return _FakeSocket(); + }, + ); + addTearDown(session.dispose); + session.start(); + await pumpEventQueue(); + online = true; + session.reconnectNow(); + await pumpEventQueue(); + expect(session.connectionState, LinkConnectionState.connected); + expect(timers.last.isActive, isFalse); + }); + + test('a moved desktop reconnects at its new address', () async { + final connects = []; + final session = LinkClientSession( + server: _record('https://10.0.0.2:47710'), + apiKey: 'key-1', + device: _device, + ensureAccess: (_) async {}, + timer: _Timers().call, + connectSocket: (uri, _, _) async { + connects.add(uri); + return _FakeSocket(); + }, + ); + addTearDown(session.dispose); + session.start(); + await pumpEventQueue(); + session.updateServer(_record('https://10.0.0.9:47711')); + await pumpEventQueue(); + expect(session.server.address, 'https://10.0.0.9:47711'); + expect(connects.map((u) => u.toString()), [ + 'wss://10.0.0.2:47710/mornye/v1/ws', + 'wss://10.0.0.9:47711/mornye/v1/ws', + ]); + expect(session.connectionState, LinkConnectionState.connected); + }); + + test('a refused key closes with 4401 and retries slowly', () async { + final timers = _Timers(); + final session = LinkClientSession( + server: _record('https://10.0.0.2:47710'), + apiKey: 'key-1', + device: _device, + ensureAccess: (_) async {}, + timer: timers.call, + connectSocket: (_, _, _) async => + _FakeSocket(closeBeforeWelcome: linkCloseUnauthorized), + ); + addTearDown(session.dispose); + session.start(); + await pumpEventQueue(); + expect(session.issue, LinkSessionIssue.unauthorized); + expect(timers.delays, [LinkClientSession.maxBackoff]); + }); + + test('an upgrade refused with 401 is unauthorized', () async { + final server = await HttpServer.bind(InternetAddress.loopbackIPv4, 0); + addTearDown(() => server.close(force: true)); + server.listen((request) async { + request.response.statusCode = 401; + await request.response.close(); + }); + final session = LinkClientSession( + server: _record('http://127.0.0.1:${server.port}'), + apiKey: 'revoked', + device: _device, + httpClient: (_) => HttpClient(), + ensureAccess: (_) async {}, + timer: _Timers().call, + ); + addTearDown(session.dispose); + session.start(); + await session.connectionStates + .firstWhere((s) => s == LinkConnectionState.disconnected) + .timeout(const Duration(seconds: 5)); + expect(session.issue, LinkSessionIssue.unauthorized); + }); + + test('a welcome of another protocol is incompatible', () async { + final session = LinkClientSession( + server: _record('https://10.0.0.2:47710'), + apiKey: 'key-1', + device: _device, + ensureAccess: (_) async {}, + timer: _Timers().call, + connectSocket: (_, _, _) async => + _FakeSocket(welcome: {..._welcome, 'protocol': 2}), + ); + addTearDown(session.dispose); + session.start(); + await pumpEventQueue(); + expect(session.connectionState, LinkConnectionState.disconnected); + expect(session.issue, LinkSessionIssue.incompatible); + }); + + test('a missing welcome times out', () async { + final timers = _Timers(); + final session = LinkClientSession( + server: _record('https://10.0.0.2:47710'), + apiKey: 'key-1', + device: _device, + ensureAccess: (_) async {}, + timer: timers.call, + handshakeTimeout: const Duration(milliseconds: 50), + connectSocket: (_, _, _) async => _FakeSocket(welcome: null), + ); + addTearDown(session.dispose); + session.start(); + await session.connectionStates + .firstWhere((s) => s == LinkConnectionState.disconnected) + .timeout(const Duration(seconds: 5)); + expect(session.issue, LinkSessionIssue.unreachable); + expect(timers.delays, [LinkClientSession.minBackoff]); + }); + }); +} diff --git a/test/link_client_store_test.dart b/test/link_client_store_test.dart new file mode 100644 index 000000000..eb7ea3fc4 --- /dev/null +++ b/test/link_client_store_test.dart @@ -0,0 +1,95 @@ +import 'dart:convert'; + +import 'package:flutter_test/flutter_test.dart'; +import 'package:mornye/services/link/client/link_client_store.dart'; +import 'package:mornye/services/link/link_client_api.dart'; +import 'package:shared_preferences/shared_preferences.dart'; + +LinkServerRecord _record(String id, {String address = 'https://10.0.0.2:1'}) => + LinkServerRecord( + serverId: id, + name: 'Desktop $id', + connectionId: 'connection-$id', + address: address, + fingerprint: 'f' * 64, + ); + +void main() { + setUp(() => SharedPreferences.setMockInitialValues({})); + + test('device id is a random UUID kept across stores', () async { + final first = await LinkClientStore().deviceId(); + expect( + first, + matches( + RegExp( + r'^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$', + ), + ), + ); + expect(await LinkClientStore().deviceId(), first); + final preferences = await SharedPreferences.getInstance(); + expect(preferences.getString(LinkClientStore.deviceIdKey), first); + }); + + test('records persist, replace by server id and keep order', () async { + final store = LinkClientStore(); + await store.upsert(_record('a')); + await store.upsert(_record('b')); + await store.upsert(_record('a', address: 'https://10.0.0.9:2')); + final servers = await LinkClientStore().servers(); + expect(servers.map((s) => s.serverId), ['a', 'b']); + expect(servers.first.address, 'https://10.0.0.9:2'); + + final preferences = await SharedPreferences.getInstance(); + final raw = jsonDecode(preferences.getString(LinkClientStore.serversKey)!); + expect(raw, [ + _record('a', address: 'https://10.0.0.9:2').toJson(), + _record('b').toJson(), + ]); + }); + + test('address updates touch only the moved desktop', () async { + final store = LinkClientStore(); + await store.upsert(_record('a')); + await store.upsert(_record('b')); + final servers = await store.updateAddress('b', 'https://10.0.0.7:47710'); + expect(servers.map((s) => s.address), [ + 'https://10.0.0.2:1', + 'https://10.0.0.7:47710', + ]); + expect(servers.last.connectionId, 'connection-b'); + expect(servers.last.fingerprint, 'f' * 64); + expect((await store.servers()).last.address, 'https://10.0.0.7:47710'); + }); + + test('removing and the active choice persist', () async { + final store = LinkClientStore(); + await store.upsert(_record('a')); + await store.upsert(_record('b')); + await store.setActiveServerId('b'); + expect(await store.activeServerId(), 'b'); + expect((await store.remove('a')).map((s) => s.serverId), ['b']); + await store.setActiveServerId(null); + expect(await store.activeServerId(), isNull); + }); + + test('broken or duplicate rows are skipped', () async { + SharedPreferences.setMockInitialValues({ + LinkClientStore.serversKey: jsonEncode([ + _record('a').toJson(), + {'serverId': 'b'}, + _record('a', address: 'https://10.0.0.3:1').toJson(), + 'junk', + ]), + }); + final servers = await LinkClientStore().servers(); + expect(servers.map((s) => s.serverId), ['a']); + expect(servers.single.address, 'https://10.0.0.2:1'); + + SharedPreferences.setMockInitialValues({ + LinkClientStore.serversKey: '{not json', + }); + expect(await LinkClientStore().servers(), isEmpty); + }); +} diff --git a/test/link_settings_page_test.dart b/test/link_settings_page_test.dart new file mode 100644 index 000000000..688505361 --- /dev/null +++ b/test/link_settings_page_test.dart @@ -0,0 +1,339 @@ +import 'package:flutter/material.dart'; +import 'package:flutter_riverpod/flutter_riverpod.dart'; +import 'package:flutter_test/flutter_test.dart'; +import 'package:mornye/l10n/l10n.dart'; +import 'package:mornye/screens/settings/link_pairing_dialogs.dart'; +import 'package:mornye/screens/settings/link_settings_page.dart'; +import 'package:mornye/services/link/client/link_client_pairing.dart'; +import 'package:mornye/theme/mornye_theme.dart'; +import 'package:mornye/widgets/app_alert_dialog.dart'; +import 'package:shared_preferences/shared_preferences.dart'; + +import 'support/link_client_fakes.dart'; + +final _l10n = lookupAppLocalizations(const Locale('en')); + +Widget _app(Widget home, {bool mornye = false}) => MaterialApp( + localizationsDelegates: AppLocalizations.localizationsDelegates, + supportedLocales: AppLocalizations.supportedLocales, + theme: mornye ? MornyeTheme.build(Brightness.light) : null, + home: home, +); + +/// Opens [dialog] from a button and keeps what it popped in [results]. The +/// Mornye dialog chrome reads providers, hence the scope. +Widget _dialogHost( + Widget dialog, + List results, { + bool mornye = false, +}) => ProviderScope( + child: _app( + mornye: mornye, + Builder( + builder: (context) => Scaffold( + body: Center( + child: TextButton( + onPressed: () async => results.add( + await showAppDialog( + context: context, + builder: (_) => dialog, + ), + ), + child: const Text('open'), + ), + ), + ), + ), + ), +); + +Future _settle(WidgetTester tester) async { + // Spinners never settle; pump past the dialog and snack bar transitions. + await tester.pump(); + await tester.pump(const Duration(milliseconds: 500)); +} + +void main() { + group('PIN dialog', () { + for (final mornye in [false, true]) { + final style = mornye ? 'Mornye' : 'Material'; + + testWidgets('$style: enables Pair at six digits and shows errors', ( + tester, + ) async { + final pins = []; + final answers = [LinkPairingError.badPin, null]; + final results = []; + await tester.pumpWidget( + _dialogHost( + LinkPinDialog( + serverName: 'Studio PC', + shortFingerprint: 'ab12cd34', + pairingOpen: true, + onSubmit: (pin) async { + pins.add(pin); + return answers.removeAt(0); + }, + ), + results, + mornye: mornye, + ), + ); + await tester.tap(find.text('open')); + await _settle(tester); + expect(find.text(_l10n.linkPinTitle('Studio PC')), findsOneWidget); + expect(find.text(_l10n.linkPinCode('ab12cd34')), findsOneWidget); + expect(find.text(_l10n.linkPinNotOpen), findsNothing); + + final field = find.byKey(LinkPinDialog.fieldKey); + await tester.enterText(field, 'ab12'); + await tester.pump(); + expect( + tester + .widget(find.byType(EditableText)) + .controller + .text, + '12', + ); + await tester.tap(find.text(_l10n.linkPair)); + await tester.pump(); + expect(pins, isEmpty); + + await tester.enterText(field, '1234567'); + await tester.pump(); + await tester.tap(find.text(_l10n.linkPair)); + await _settle(tester); + expect(pins, ['123456']); + expect(find.text(_l10n.linkErrorBadPin), findsOneWidget); + expect( + tester + .widget(find.byType(EditableText)) + .controller + .text, + isEmpty, + ); + + await tester.enterText(field, '654321'); + await tester.pump(); + await tester.tap(find.text(_l10n.linkPair)); + await _settle(tester); + expect(pins, ['123456', '654321']); + expect(results, [true]); + expect(find.byType(LinkPinDialog), findsNothing); + }); + } + + testWidgets('says when the computer is not ready to pair', (tester) async { + final results = []; + await tester.pumpWidget( + _dialogHost( + LinkPinDialog( + serverName: 'Studio PC', + shortFingerprint: 'ab12cd34', + pairingOpen: false, + onSubmit: (_) async => LinkPairingError.pairingClosed, + ), + results, + ), + ); + await tester.tap(find.text('open')); + await _settle(tester); + expect(find.text(_l10n.linkPinNotOpen), findsOneWidget); + await tester.enterText(find.byKey(LinkPinDialog.fieldKey), '123456'); + await tester.pump(); + await tester.tap(find.text(_l10n.linkPair)); + await _settle(tester); + expect(find.text(_l10n.linkErrorPairingClosed), findsOneWidget); + await tester.tap(find.text(_l10n.dialogCancel)); + await _settle(tester); + expect(results, [false]); + }); + + test('every pairing error has its own message', () { + final messages = { + for (final error in LinkPairingError.values) + error: linkPairingErrorMessage(_l10n, error), + }; + expect(messages.values.every((m) => m.isNotEmpty), isTrue); + expect( + messages.values.toSet(), + hasLength(LinkPairingError.values.length), + ); + expect( + messages[LinkPairingError.tooManyAttempts], + _l10n.linkErrorTooManyAttempts, + ); + expect( + messages[LinkPairingError.certificateMismatch], + _l10n.linkErrorCertificate, + ); + }); + }); + + group('manual address', () { + test('accepts hosts, host:port, URLs and IPv6', () { + expect(linkParseManualAddress(' 192.168.1.20 ', '47710'), ( + host: '192.168.1.20', + port: 47710, + )); + expect(linkParseManualAddress('studio.local:5000', '47710'), ( + host: 'studio.local', + port: 5000, + )); + expect(linkParseManualAddress('https://10.0.0.2:47711/mornye', '1'), ( + host: '10.0.0.2', + port: 47711, + )); + expect(linkParseManualAddress('[fe80::2]:47712', '1'), ( + host: 'fe80::2', + port: 47712, + )); + expect(linkParseManualAddress('fe80::2', '47710'), ( + host: 'fe80::2', + port: 47710, + )); + }); + + test('refuses what is not an address', () { + for (final (host, port) in [ + ('', '47710'), + ('10.0.0.2', ''), + ('10.0.0.2', '0'), + ('10.0.0.2', '70000'), + ('my computer', '47710'), + ('user@10.0.0.2', '47710'), + ('not:an:address', '47710'), + ]) { + expect(linkParseManualAddress(host, port), isNull, reason: host); + } + }); + + for (final mornye in [false, true]) { + testWidgets('${mornye ? 'Mornye' : 'Material'}: dialog checks input', ( + tester, + ) async { + final results = []; + await tester.pumpWidget( + _dialogHost(const LinkManualAddDialog(), results, mornye: mornye), + ); + await tester.tap(find.text('open')); + await _settle(tester); + await tester.enterText( + find.byKey(LinkManualAddDialog.hostKey), + 'my computer', + ); + await tester.tap(find.text(_l10n.linkContinue)); + await tester.pump(); + expect(find.text(_l10n.linkErrorInvalidAddress), findsOneWidget); + + await tester.enterText( + find.byKey(LinkManualAddDialog.hostKey), + '10.0.0.5:5000', + ); + await tester.tap(find.text(_l10n.linkContinue)); + await _settle(tester); + expect(results, [(host: '10.0.0.5', port: 5000)]); + }); + } + }); + + group('page', () { + setUp(() => SharedPreferences.setMockInitialValues({})); + + Future pumpPage( + WidgetTester tester, { + bool mornye = false, + bool localNetworkAllowed = true, + bool onWifi = true, + }) async { + final harness = LinkClientHarness() + ..localNetworkAllowed = localNetworkAllowed + ..onWifi = onWifi; + await tester.pumpWidget( + ProviderScope( + overrides: harness.overrides, + child: _app(const LinkSettingsPage(), mornye: mornye), + ), + ); + await _settle(tester); + return harness; + } + + for (final mornye in [false, true]) { + testWidgets( + '${mornye ? 'Mornye' : 'Material'}: pairs a nearby computer', + (tester) async { + final harness = await pumpPage(tester, mornye: mornye); + expect(find.text(_l10n.linkSearching), findsOneWidget); + expect(harness.browser.started, 1); + harness.pairing.targets['10.0.0.3'] = linkTestTarget( + 'b', + host: '10.0.0.3', + ); + harness.browser.resolve('b', '10.0.0.3'); + await _settle(tester); + expect(find.text('Desktop b'), findsOneWidget); + + await tester.tap(find.text('Desktop b')); + await _settle(tester); + expect( + harness.pairing.probes.single.expectedFingerprint, + linkTestFingerprint('b'), + ); + await tester.enterText(find.byKey(LinkPinDialog.fieldKey), '123456'); + await tester.pump(); + await tester.tap(find.text(_l10n.linkPair)); + await _settle(tester); + expect(harness.pairing.pins, ['123456']); + expect(find.byType(LinkPinDialog), findsNothing); + expect(find.text(_l10n.linkPaired('Desktop b')), findsOneWidget); + expect(find.text(_l10n.linkPairedSection), findsOneWidget); + expect(harness.sessions.single.server.serverId, 'b'); + + // Leaving the page stops discovery. + await tester.pumpWidget(const SizedBox()); + await tester.pump(); + }, + ); + } + + testWidgets('warns when the certificate does not match', (tester) async { + final harness = await pumpPage(tester); + harness.pairing.probeError = LinkPairingError.certificateMismatch; + harness.browser.resolve('b', '10.0.0.3'); + await _settle(tester); + await tester.tap(find.text('Desktop b')); + await _settle(tester); + expect(find.text(_l10n.linkErrorCertificateTitle), findsOneWidget); + expect(find.text(_l10n.linkErrorCertificate), findsOneWidget); + expect(find.byType(LinkPinDialog), findsNothing); + await tester.pumpWidget(const SizedBox()); + await tester.pump(); + }); + + testWidgets('asks for local network access', (tester) async { + final harness = await pumpPage(tester, localNetworkAllowed: false); + expect(find.text(_l10n.linkLocalNetworkTitle), findsOneWidget); + expect(harness.browser.started, 0); + + await tester.tap(find.text(_l10n.linkLocalNetworkAllow)); + await _settle(tester); + expect(find.text(_l10n.networkErrorLocalPermission), findsOneWidget); + + harness.localNetworkAllowed = true; + await tester.tap(find.text(_l10n.linkLocalNetworkAllow)); + await _settle(tester); + expect(harness.browser.started, 1); + expect(find.text(_l10n.linkLocalNetworkTitle), findsNothing); + await tester.pumpWidget(const SizedBox()); + await tester.pump(); + }); + + testWidgets('says when Wi-Fi is off', (tester) async { + await pumpPage(tester, onWifi: false); + expect(find.text(_l10n.linkWifiOffTitle), findsOneWidget); + await tester.pumpWidget(const SizedBox()); + await tester.pump(); + }); + }); +} diff --git a/test/support/link_client_fakes.dart b/test/support/link_client_fakes.dart new file mode 100644 index 000000000..0a6450486 --- /dev/null +++ b/test/support/link_client_fakes.dart @@ -0,0 +1,266 @@ +import 'dart:async'; + +import 'package:flutter_riverpod/flutter_riverpod.dart'; +import 'package:flutter_riverpod/misc.dart' show Override; +import 'package:mornye/services/link/client/link_client_controller.dart'; +import 'package:mornye/services/link/client/link_client_discovery.dart'; +import 'package:mornye/services/link/client/link_client_library.dart'; +import 'package:mornye/services/link/client/link_client_pairing.dart'; +import 'package:mornye/services/link/client/link_client_session.dart'; +import 'package:mornye/services/link/client/link_client_store.dart'; +import 'package:mornye/services/link/link_client_api.dart'; +import 'package:mornye/services/link/link_protocol.dart'; +import 'package:mornye/services/local_network_access.dart'; +import 'package:mornye/services/network_storage_service.dart'; + +/// A stable fake certificate fingerprint per server id. +String linkTestFingerprint(String serverId) => + serverId.codeUnitAt(0).toRadixString(16).padLeft(2, '0') * 32; + +LinkPairingTarget linkTestTarget( + String serverId, { + String host = '10.0.0.2', + bool pairing = true, +}) => LinkPairingTarget( + address: 'https://$host:47710', + info: LinkServerInfo( + serverId: serverId, + name: 'Desktop $serverId', + protocol: linkProtocolVersion, + appVersion: '5.3.0', + fingerprint: linkTestFingerprint(serverId), + pairing: pairing, + ), +); + +class FakeLinkSession implements LinkSession { + FakeLinkSession(this.server, this.apiKey); + + @override + LinkServerRecord server; + final String apiKey; + final _states = StreamController.broadcast(); + final _messages = StreamController>.broadcast(); + final calls = []; + bool disposed = false; + + @override + LinkConnectionState connectionState = LinkConnectionState.disconnected; + + @override + LinkSessionIssue? issue; + + void emit(LinkConnectionState state, [LinkSessionIssue? reason]) { + connectionState = state; + issue = reason; + _states.add(state); + } + + void push(Map message) => _messages.add(message); + + @override + Stream get connectionStates => _states.stream; + + @override + Stream> get messages => _messages.stream; + + @override + void send(Map message) => calls.add('send'); + + @override + Future get(String op, [Map query = const {}]) => + throw UnimplementedError(); + + @override + Future post(String op, Map body) => + throw UnimplementedError(); + + @override + void start() => calls.add('start'); + + @override + void pause() => calls.add('pause'); + + @override + void resume() => calls.add('resume'); + + @override + void reconnectNow() => calls.add('reconnect'); + + @override + void updateServer(LinkServerRecord server) { + this.server = server; + calls.add('update ${server.address}'); + } + + @override + Future dispose() async { + disposed = true; + await _states.close(); + await _messages.close(); + } +} + +class FakeLinkBrowser implements LinkServiceBrowser { + StreamController? events; + int started = 0; + int stopped = 0; + + @override + Future> start() async { + started++; + events = StreamController(); + return events!.stream; + } + + @override + Future stop() async { + stopped++; + unawaited(events?.close()); + events = null; + } + + /// A desktop advertising [serverId] at [host]. + void resolve(String serverId, String host, {String? fingerprint}) => + events!.add( + LinkServiceResolved( + name: 'Desktop $serverId', + port: 47710, + addresses: [host], + attributes: { + 'v': '1', + 'id': serverId, + 'fp': fingerprint ?? linkTestFingerprint(serverId), + }, + ), + ); +} + +class FakeLinkBridge implements LinkLibraryBridge { + final connections = {}; + final calls = []; + + @override + Future connection(String connectionId) async => + connections[connectionId]; + + @override + Future saveConnection(NetworkConnection connection) async { + connections[connection.id] = connection; + calls.add('save ${connection.id}'); + } + + @override + Future updateAddress(String connectionId, String address) async => + calls.add('address $connectionId $address'); + + @override + Future addLibrarySource(NetworkConnection connection) async => + calls.add('source ${connection.id}'); + + @override + Future rescan(String connectionId) async => + calls.add('rescan $connectionId'); + + @override + Future removeConnection(String connectionId) async { + connections.remove(connectionId); + calls.add('remove $connectionId'); + } +} + +class FakeLinkPairing implements LinkPairingApi { + /// Desktops [probe] finds, by host. + final targets = {}; + final probes = <({Uri address, String? expectedFingerprint})>[]; + final pins = []; + final devices = []; + String key = 'key-1'; + LinkPairingError? probeError; + LinkPairingError? error; + + @override + Future probe( + Uri address, { + String? expectedFingerprint, + }) async { + probes.add((address: address, expectedFingerprint: expectedFingerprint)); + if (probeError case final error?) throw LinkPairingException(error); + final target = targets[address.host]; + if (target == null) { + throw const LinkPairingException(LinkPairingError.unreachable); + } + return target; + } + + @override + Future pair( + LinkPairingTarget target, { + required String pin, + required LinkDeviceIdentity device, + }) async { + pins.add(pin); + devices.add(device); + if (error case final error?) throw LinkPairingException(error); + return LinkPairingResult( + apiKey: key, + serverId: target.info.serverId, + name: target.info.name, + fingerprint: target.fingerprint, + ); + } +} + +/// The client's providers wired to fakes. Tests set +/// `SharedPreferences.setMockInitialValues` first. +class LinkClientHarness { + LinkClientHarness({this.supported = true}); + + final bool supported; + final browser = FakeLinkBrowser(); + final bridge = FakeLinkBridge(); + final pairing = FakeLinkPairing(); + final sessions = []; + bool localNetworkAllowed = true; + bool onWifi = true; + + List get overrides => [ + linkClientSupportedProvider.overrideWithValue(supported), + linkClientEnvironmentProvider.overrideWithValue( + LinkClientEnvironment( + deviceName: () async => 'Test phone', + platform: 'android', + appVersion: '5.3.0', + createBrowser: () => browser, + createSession: (server, apiKey, device) { + final session = FakeLinkSession(server, apiKey); + sessions.add(session); + return session; + }, + ensureLocalNetwork: () async { + if (!localNetworkAllowed) { + throw const LocalNetworkPermissionException(); + } + }, + onLocalNetwork: () async => onWifi, + ), + ), + linkClientStoreProvider.overrideWithValue(LinkClientStore()), + linkPairingApiProvider.overrideWithValue(pairing), + linkLibraryBridgeProvider.overrideWithValue(bridge), + ]; + + late final container = ProviderContainer(overrides: overrides); + + LinkClientController get controller => + container.read(linkClientControllerProvider.notifier); + LinkClientState get state => container.read(linkClientControllerProvider); + LinkClientApi? get active => container.read(linkActiveClientProvider); + + /// Keeps the controller alive, as the app root does, and waits for it to + /// load. + Future start() async { + container.listen(linkClientControllerProvider, (_, _) {}); + await controller.ready; + } +} diff --git a/windows/flutter/generated_plugin_registrant.cc b/windows/flutter/generated_plugin_registrant.cc index c4368450e..e6b82b292 100644 --- a/windows/flutter/generated_plugin_registrant.cc +++ b/windows/flutter/generated_plugin_registrant.cc @@ -8,6 +8,7 @@ #include #include +#include #include #include #include @@ -24,6 +25,8 @@ void RegisterPlugins(flutter::PluginRegistry* registry) { registry->GetRegistrarForPlugin("AppLinksPluginCApi")); AudioplayersWindowsPluginRegisterWithRegistrar( registry->GetRegistrarForPlugin("AudioplayersWindowsPlugin")); + BonsoirWindowsPluginCApiRegisterWithRegistrar( + registry->GetRegistrarForPlugin("BonsoirWindowsPluginCApi")); ConnectivityPlusWindowsPluginRegisterWithRegistrar( registry->GetRegistrarForPlugin("ConnectivityPlusWindowsPlugin")); DesktopDropPluginRegisterWithRegistrar( diff --git a/windows/flutter/generated_plugins.cmake b/windows/flutter/generated_plugins.cmake index 0772fd56c..107e3e7fe 100644 --- a/windows/flutter/generated_plugins.cmake +++ b/windows/flutter/generated_plugins.cmake @@ -5,6 +5,7 @@ list(APPEND FLUTTER_PLUGIN_LIST app_links audioplayers_windows + bonsoir_windows connectivity_plus desktop_drop dynamic_color