Files
zarzet 9b17fd2c61 feat(link): offer only what the Link host announces
Hosts announce their platform and optional features (downloads, opening
links, file changes). The phone remembers them and hides the actions a
host lacks, and shows a phone icon for a phone host. Older hosts that
announce nothing keep every action.
2026-11-17 03:09:29 +07:00

951 lines
32 KiB
Dart

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/connectivity_monitor.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/features/link_phone_options.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/services/platform_bridge.dart';
import 'package:mornye/utils/logger.dart';
final _log = AppLogger('LinkClient');
/// Whether this device runs the phone side of Mornye Link.
final linkClientSupportedProvider = Provider<bool>(
(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,
this.networkChanges = const Stream<void>.empty(),
this.updateBackgroundConnection,
});
/// The name desktops list this phone under.
final Future<String> 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<void> Function() ensureLocalNetwork;
/// Whether Wi-Fi or Ethernet is connected.
final Future<bool> Function() onLocalNetwork;
/// Interface changes can invalidate discovery even when Wi-Fi stays on.
final Stream<void> networkChanges;
/// Holds Android's connected-device foreground service for this computer,
/// or releases it when [name] is null. Other platforms need no service.
final Future<void> Function(String? name)? updateBackgroundConnection;
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,
networkChanges: ConnectivityMonitor.instance.changes.map((_) {}),
updateBackgroundConnection: _updateBackgroundConnection,
);
static Future<void> _updateBackgroundConnection(String? name) async {
if (!Platform.isAndroid) return;
if (name == null) {
await PlatformBridge.stopLinkConnectionService();
} else if (!await PlatformBridge.startLinkConnectionService(name)) {
throw StateError('Android could not keep the Link connection active');
}
}
static Future<String> _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<bool> _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<LinkClientEnvironment>(
(ref) => LinkClientEnvironment.device(),
);
final linkClientStoreProvider = Provider<LinkClientStore>(
(ref) => LinkClientStore(),
);
final linkPairingApiProvider = Provider<LinkPairingApi>(
(ref) => LinkPairingClient(),
);
final linkLibraryBridgeProvider = Provider<LinkLibraryBridge>(
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<LinkServerRecord> 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<LinkDiscoveredServer> 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<LinkDiscoveredServer> 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<LinkServerRecord>? servers,
String? activeServerId,
bool clearActiveServer = false,
LinkConnectionState? connection,
LinkSessionIssue? issue,
bool clearIssue = false,
List<LinkDiscoveredServer>? 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<LinkClientState> {
/// How long `catalog.changed` bursts settle before a rescan.
static const rescanDelay = Duration(seconds: 2);
static const discoveryRetryDelay = Duration(seconds: 2);
static const discoveryRefreshInterval = Duration(seconds: 15);
static const networkDiscoveryDuration = Duration(seconds: 30);
LinkSession? _session;
StreamSubscription<LinkConnectionState>? _stateSubscription;
StreamSubscription<Map<String, dynamic>>? _messageSubscription;
LinkDiscovery? _discovery;
AppLifecycleListener? _lifecycle;
StreamSubscription<void>? _networkSubscription;
Timer? _discoveryRetry;
Timer? _discoveryRefresh;
Timer? _networkDiscovery;
var _discoveryFailures = 0;
var _restartingDiscovery = false;
Timer? _rescan;
Future<void> _mutation = Future.value();
Future<void>? _loading;
LinkDeviceIdentity? _device;
var _foreground = true;
var _android = false;
Future<void> Function(String?)? _backgroundUpdater;
Future<void> _backgroundUpdates = Future.value();
String? _backgroundName;
/// [linkKeepConnectedProvider]: the session stays connected in the
/// background too.
var _keepConnected = false;
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);
bool get _showComputerSongs =>
ref.read(linkPhoneOptionsProvider).showComputerSongs;
/// Completes once paired desktops are loaded and the session started.
Future<void> ensureLoaded() => _loading ?? Future.value();
@override
LinkClientState build() {
if (!ref.watch(linkClientSupportedProvider)) {
return const LinkClientState(loaded: true);
}
_disposed = false;
final environment = _environment;
_android = environment.platform == 'android';
_backgroundUpdater = _android
? environment.updateBackgroundConnection
: null;
_lifecycle = AppLifecycleListener(onStateChange: _onLifecycle);
_networkSubscription = _environment.networkChanges.listen(
(_) => unawaited(_refreshNetworkConnection()),
onError: (Object error) =>
_log.w('Watching local network failed: $error'),
);
ref.listen(
linkKeepConnectedProvider,
(_, keep) => _updateConnected(() => _keepConnected = keep),
fireImmediately: true,
);
ref.listen(linkPhoneOptionsProvider, (previous, next) {
if (!next.loaded ||
previous?.loaded != true ||
previous?.showComputerSongs == next.showComputerSongs) {
return;
}
_rescan?.cancel();
unawaited(
_serial(_syncLibrarySources).catchError(
(Object error) =>
_log.w('Updating computer songs in Library failed: $error'),
),
);
});
ref.onDispose(_dispose);
_loading = Future<void>.microtask(
() => _serial(_load).catchError(
(Object error, StackTrace stack) =>
_log.e('Loading paired computers failed', error, stack),
),
);
return const LinkClientState();
}
Future<T> _serial<T>(Future<T> Function() action) {
final result = _mutation.then((_) => action());
_mutation = result.then<void>((_) {}, onError: (Object _) {});
return result;
}
Future<void> _load() async {
await ref.read(linkPhoneOptionsProvider.notifier).ensureLoaded();
if (_disposed) return;
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,
);
if (!_showComputerSongs) await _syncLibrarySources();
if (!_disposed) await _restartSession();
}
Future<void> _syncLibrarySources() async {
if (_disposed) return;
final enabled = _showComputerSongs;
for (final server in state.servers) {
if (_disposed) return;
try {
await _library.setLibrarySourceEnabled(server.connectionId, enabled);
} on Object catch (error) {
_log.w('Updating ${server.name} songs in Library failed: $error');
}
}
}
Future<LinkDeviceIdentity> _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<void> _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();
unawaited(_syncBackgroundConnection());
if (next != null) {
if (!_connected) next.pause();
next.start();
}
_updateDiscovery();
}
void _onConnection(LinkSession session) {
if (_disposed || !identical(session, _session)) return;
final wasConnected = state.connection == LinkConnectionState.connected;
state = state.copyWith(
connection: session.connectionState,
issue: session.issue,
clearIssue: session.issue == null,
);
_library.setReachable(
session.server.connectionId,
reachable: session.issue != LinkSessionIssue.unreachable,
);
unawaited(_syncBackgroundConnection());
if (!_connected) session.pause();
_updateDiscovery();
if (session.connectionState != LinkConnectionState.connected) {
_rescan?.cancel();
_rescan = null;
} else if (!wasConnected) {
// A catalog notification can be lost while the phone is offline or
// suspended, even when the desktop believes it was delivered.
_scheduleRescan(session);
unawaited(_rememberAnnounced(session.server));
}
}
/// Stores what the host announced in its welcome (its platform and
/// abilities) for labels and for the next start.
Future<void> _rememberAnnounced(LinkServerRecord announced) =>
_serial(() async {
final stored = state.servers
.where((s) => s.serverId == announced.serverId)
.firstOrNull;
if (_disposed || stored == null) return;
final updated = stored.announced(
platform: announced.platform,
features: announced.features,
);
if (identical(updated, stored)) return;
final servers = await _store.upsert(updated);
if (!_disposed) state = state.copyWith(servers: servers);
}).catchError(
(Object error) => _log.w('Saving the host details failed: $error'),
);
void _onMessage(LinkSession session, Map<String, dynamic> message) {
if (_disposed || !identical(session, _session)) return;
if (message['type'] != LinkMessageTypes.catalogChanged) return;
_scheduleRescan(session);
}
void _scheduleRescan(LinkSession session) {
final connectionId = session.server.connectionId;
_rescan?.cancel();
if (!_showComputerSongs) return;
_rescan = Timer(rescanDelay, () {
_rescan = null;
if (_disposed ||
!_showComputerSongs ||
!identical(session, _session) ||
session.connectionState != LinkConnectionState.connected) {
return;
}
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 || _disposed) return;
final foreground = lifecycle == AppLifecycleState.resumed;
if (foreground == _foreground && !foreground) return;
_updateConnected(() => _foreground = foreground);
if (foreground) {
unawaited(_syncBackgroundConnection(force: true));
// Control Centre and permission dialogs can change the network without
// ever putting the app into the paused lifecycle state.
unawaited(_refreshNetworkConnection());
} else {
_updateDiscovery();
}
}
bool get _backgroundConnectionWanted =>
_android &&
_session != null &&
switch (_session!.issue) {
null || LinkSessionIssue.unreachable => true,
_ => false,
};
/// Android remains an available playback target even while idle. iOS keeps
/// its existing playback/transfer lease because its OS can suspend the app.
bool get _connected =>
_foreground || _keepConnected || _backgroundConnectionWanted;
Future<void> _syncBackgroundConnection({bool force = false}) {
final update = _backgroundUpdater;
if (update == null) return Future.value();
final name = !_disposed && _backgroundConnectionWanted
? _session!.server.name
: null;
// A late start must finish before an unpair/disposal releases its service.
return _backgroundUpdates = _backgroundUpdates
.then((_) async {
if (!force && name == _backgroundName) return;
await update(name);
_backgroundName = name;
})
.catchError(
(Object error) =>
_log.w('Updating Link background connection failed: $error'),
);
}
/// Applies [change], then pauses or resumes the session when that changed
/// [_connected].
void _updateConnected(void Function() change) {
final was = _connected;
change();
if (_connected == was || _disposed) return;
if (_connected) {
_session?.resume();
} else {
_session?.pause();
}
if (!_foreground) _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<void>.microtask(refreshLocalNetwork));
var released = false;
return () {
if (released) return;
released = true;
_discoveryHolds--;
scheduleMicrotask(_updateDiscovery);
};
}
void _updateDiscovery() {
if (_disposed || _restartingDiscovery) return;
if (!_connected || !state.localNetworkAvailable || _session == null) {
_networkDiscovery?.cancel();
_networkDiscovery = null;
}
final reconnecting =
_session != null && state.connection != LinkConnectionState.connected;
final wanted =
_connected &&
state.localNetworkAvailable &&
!_discoveryBlocked &&
((_foreground && _discoveryHolds > 0) ||
reconnecting ||
_networkDiscovery != null);
final discovery = _discovery ??= LinkDiscovery(
createBrowser: _environment.createBrowser,
ensureAccess: _environment.ensureLocalNetwork,
onChanged: _onDiscoveryChanged,
);
if (!wanted) {
_discoveryRetry?.cancel();
_discoveryRetry = null;
_discoveryFailures = 0;
}
if (wanted &&
_discoveryRetry == null &&
discovery.status != LinkDiscoveryStatus.searching) {
unawaited(discovery.start());
} else if (!wanted && discovery.status == LinkDiscoveryStatus.searching) {
unawaited(discovery.stop());
}
// Older NSD/Bonjour resolvers can keep the first IP indefinitely without
// emitting an update. Recreate them only while a session needs recovery.
if (wanted && reconnecting && discovery.running) {
_discoveryRefresh ??= Timer(discoveryRefreshInterval, () {
_discoveryRefresh = null;
unawaited(_restartDiscovery());
});
} else {
_discoveryRefresh?.cancel();
_discoveryRefresh = null;
}
}
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.running) {
_discoveryRefresh?.cancel();
_discoveryRefresh = null;
}
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);
if (discovery.status == LinkDiscoveryStatus.failed &&
_connected &&
state.localNetworkAvailable &&
!_discoveryBlocked &&
_discoveryRetry == null) {
final delay = discoveryRetryDelay * (1 << _discoveryFailures.clamp(0, 4));
_discoveryFailures++;
_discoveryRetry = Timer(delay, () {
_discoveryRetry = null;
_updateDiscovery();
});
} else if (found.isNotEmpty) {
_discoveryFailures = 0;
}
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,
fingerprint: server.fingerprint,
),
).catchError(
(Object error) =>
_log.w('Updating the computer address failed: $error'),
),
);
} else if (!before.contains(server.serverId) &&
record.serverId == state.activeServerId) {
_session?.reconnectNow();
}
}
}
Future<void> _move(
String serverId,
String address, {
required String fingerprint,
}) async {
final record = state.servers
.where((s) => s.serverId == serverId)
.firstOrNull;
if (record == null ||
record.fingerprint != fingerprint ||
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<void> refreshLocalNetwork() async {
if (_disposed) return;
final available = await _environment.onLocalNetwork();
if (_disposed || available == state.localNetworkAvailable) return;
state = state.copyWith(localNetworkAvailable: available);
_updateDiscovery();
}
Future<void> _refreshNetworkConnection() async {
await refreshLocalNetwork();
if (_disposed) return;
_networkDiscovery?.cancel();
_networkDiscovery = null;
if (_connected && state.localNetworkAvailable && _session != null) {
// TCP may still look connected after changing Wi-Fi or waking the app.
// Resolve the desktop again without interrupting a healthy socket.
_networkDiscovery = Timer(networkDiscoveryDuration, () {
_networkDiscovery = null;
_updateDiscovery();
});
}
await _restartDiscovery();
if (!_disposed &&
_connected &&
state.localNetworkAvailable &&
state.connection != LinkConnectionState.connected) {
_session?.reconnectNow();
}
}
Future<void> _restartDiscovery() async {
if (_disposed || _restartingDiscovery) return;
_restartingDiscovery = true;
_discoveryRetry?.cancel();
_discoveryRetry = null;
_discoveryRefresh?.cancel();
_discoveryRefresh = null;
_discoveryFailures = 0;
try {
await _discovery?.stop();
} finally {
_restartingDiscovery = false;
_updateDiscovery();
}
}
/// Asks for local network access again, then retries discovery and the
/// session. Throws [LocalNetworkPermissionException] when refused.
Future<void> requestLocalNetworkAccess() async {
if (_disposed) return;
await _environment.ensureLocalNetwork();
if (_disposed) return;
_discoveryBlocked = false;
await _restartDiscovery();
_session?.reconnectNow();
}
/// Retries the active desktop now.
void retry() {
unawaited(_restartDiscovery());
_session?.reconnectNow();
}
/// Reads a desktop's `info` before asking for its PIN.
Future<LinkPairingTarget> 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);
}
/// Reuses a paired computer after a certificate-checked [probe], including
/// a manually entered new IP. A missing or refused key still needs a PIN.
Future<bool> reconnectPaired(LinkPairingTarget target) => _serial(() async {
if (_disposed) return false;
final record = state.servers
.where((server) => server.serverId == target.info.serverId)
.firstOrNull;
if (record == null) return false;
if (record.fingerprint != target.fingerprint) {
throw const LinkPairingException(LinkPairingError.certificateMismatch);
}
final connection = await _library.connection(record.connectionId);
if (_disposed || connection == null || connection.apiKey.isEmpty) {
return false;
}
final active = state.activeServerId == record.serverId;
if (active && state.issue == LinkSessionIssue.unauthorized) return false;
await _move(
record.serverId,
target.address,
fingerprint: target.fingerprint,
);
if (_disposed) return false;
if (!active) {
await _store.setActiveServerId(record.serverId);
if (_disposed) return false;
state = state.copyWith(activeServerId: record.serverId);
await _restartSession();
} else {
_session?.reconnectNow();
}
return true;
});
/// Pairs with [target] using [pin]. On success the desktop is saved as a
/// Subsonic network connection and, when enabled, added to Library and
/// scanned. Re-pairing replaces the stored key. Throws [LinkPairingException].
Future<LinkServerRecord> 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,
platform: target.info.platform,
features: target.info.features,
);
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(
_serial(() async {
if (_disposed) return;
if (_showComputerSongs) {
await _library.addLibrarySource(connection);
} else {
await _library.setLibrarySourceEnabled(connection.id, false);
}
}).catchError(
(Object error) =>
_log.w('Adding the computer to Library failed: $error'),
),
);
return record;
}
/// Makes [serverId] the desktop features talk to.
Future<void> 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<void> 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;
unawaited(_syncBackgroundConnection());
_lifecycle?.dispose();
_lifecycle = null;
unawaited(_networkSubscription?.cancel());
_networkSubscription = null;
_discoveryRetry?.cancel();
_discoveryRefresh?.cancel();
_networkDiscovery?.cancel();
_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, LinkClientState>(
LinkClientController.new,
);