241 lines
8.6 KiB
Dart
241 lines
8.6 KiB
Dart
import 'package:flutter/material.dart';
|
|
|
|
import 'package:collection/collection.dart' show IterableExtension;
|
|
import 'package:fluffychat/generated/l10n/l10n.dart';
|
|
import 'package:go_router/go_router.dart';
|
|
import 'package:matrix/matrix.dart';
|
|
import 'package:punycode/punycode.dart';
|
|
import 'package:url_launcher/url_launcher_string.dart';
|
|
|
|
import 'package:fluffychat/config/app_config.dart';
|
|
import 'package:fluffychat/widgets/adaptive_dialogs/show_ok_cancel_alert_dialog.dart';
|
|
import 'package:fluffychat/widgets/adaptive_dialogs/user_dialog.dart';
|
|
import 'package:fluffychat/widgets/future_loading_dialog.dart';
|
|
import 'package:fluffychat/widgets/matrix.dart';
|
|
import '../widgets/adaptive_dialogs/public_room_dialog.dart';
|
|
import 'platform_infos.dart';
|
|
|
|
class UrlLauncher {
|
|
/// The url to open.
|
|
final String? url;
|
|
|
|
/// The visible name in the GUI. For example the name of a markdown link
|
|
/// which may differ from the actual url to open.
|
|
final String? name;
|
|
|
|
final BuildContext context;
|
|
|
|
const UrlLauncher(this.context, this.url, [this.name]);
|
|
|
|
void launchUrl() async {
|
|
if (url!.toLowerCase().startsWith(AppConfig.deepLinkPrefix) ||
|
|
url!.toLowerCase().startsWith(AppConfig.inviteLinkPrefix) ||
|
|
{'#', '@', '!', '+', '\$'}.contains(url![0]) ||
|
|
url!.toLowerCase().startsWith(AppConfig.schemePrefix)) {
|
|
return openMatrixToUrl();
|
|
}
|
|
final uri = Uri.tryParse(url!);
|
|
if (uri == null) {
|
|
// we can't open this thing
|
|
ScaffoldMessenger.of(context).showSnackBar(
|
|
SnackBar(content: Text(L10n.of(context).cantOpenUri(url!))),
|
|
);
|
|
return;
|
|
}
|
|
|
|
if (name != null && url != name) {
|
|
// If there is a name which differs from the url, we need to make sure
|
|
// that the user can see the actual url before opening the browser.
|
|
final consent = await showOkCancelAlertDialog(
|
|
context: context,
|
|
title: L10n.of(context).openLinkInBrowser,
|
|
message: url,
|
|
okLabel: L10n.of(context).open,
|
|
cancelLabel: L10n.of(context).cancel,
|
|
);
|
|
if (consent != OkCancelResult.ok) return;
|
|
}
|
|
|
|
if (!{'https', 'http'}.contains(uri.scheme)) {
|
|
// just launch non-https / non-http uris directly
|
|
|
|
// we need to transmute geo URIs on desktop and on iOS
|
|
if ((!PlatformInfos.isMobile || PlatformInfos.isIOS) &&
|
|
uri.scheme == 'geo') {
|
|
final latlong = uri.path
|
|
.split(';')
|
|
.first
|
|
.split(',')
|
|
.map((s) => double.tryParse(s))
|
|
.toList();
|
|
if (latlong.length == 2 &&
|
|
latlong.first != null &&
|
|
latlong.last != null) {
|
|
if (PlatformInfos.isIOS) {
|
|
// iOS is great at not following standards, so we need to transmute the geo URI
|
|
// to an apple maps thingy
|
|
// https://developer.apple.com/library/archive/featuredarticles/iPhoneURLScheme_Reference/MapLinks/MapLinks.html
|
|
final ll = '${latlong.first},${latlong.last}';
|
|
launchUrlString('https://maps.apple.com/?q=$ll&sll=$ll');
|
|
} else {
|
|
// transmute geo URIs on desktop to openstreetmap links, as those usually can't handle
|
|
// geo URIs
|
|
launchUrlString(
|
|
'https://www.openstreetmap.org/?mlat=${latlong.first}&mlon=${latlong.last}#map=16/${latlong.first}/${latlong.last}',
|
|
);
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
launchUrlString(url!);
|
|
return;
|
|
}
|
|
if (uri.host.isEmpty) {
|
|
ScaffoldMessenger.of(context).showSnackBar(
|
|
SnackBar(content: Text(L10n.of(context).cantOpenUri(url!))),
|
|
);
|
|
return;
|
|
}
|
|
// okay, we have either an http or an https URI.
|
|
// As some platforms have issues with opening unicode URLs, we are going to help
|
|
// them out by punycode-encoding them for them ourself.
|
|
final newHost = uri.host.split('.').map((hostPartEncoded) {
|
|
final hostPart = Uri.decodeComponent(hostPartEncoded);
|
|
final hostPartPunycode = punycodeEncode(hostPart);
|
|
return hostPartPunycode != '$hostPart-'
|
|
? 'xn--$hostPartPunycode'
|
|
: hostPart;
|
|
}).join('.');
|
|
// Force LaunchMode.externalApplication, otherwise url_launcher will default
|
|
// to opening links in a webview on mobile platforms.
|
|
launchUrlString(
|
|
uri.replace(host: newHost).toString(),
|
|
mode: LaunchMode.externalApplication,
|
|
);
|
|
}
|
|
|
|
void openMatrixToUrl() async {
|
|
final matrix = Matrix.of(context);
|
|
final url = this.url!.replaceFirst(
|
|
AppConfig.deepLinkPrefix,
|
|
AppConfig.inviteLinkPrefix,
|
|
);
|
|
|
|
// The identifier might be a matrix.to url and needs escaping. Or, it might have multiple
|
|
// identifiers (room id & event id), or it might also have a query part.
|
|
// All this needs parsing.
|
|
final identityParts = url.parseIdentifierIntoParts() ??
|
|
Uri.tryParse(url)?.host.parseIdentifierIntoParts() ??
|
|
Uri.tryParse(url)
|
|
?.pathSegments
|
|
.lastWhereOrNull((_) => true)
|
|
?.parseIdentifierIntoParts();
|
|
if (identityParts == null) {
|
|
return; // no match, nothing to do
|
|
}
|
|
if (identityParts.primaryIdentifier.sigil == '#' ||
|
|
identityParts.primaryIdentifier.sigil == '!') {
|
|
// we got a room! Let's open that one
|
|
final roomIdOrAlias = identityParts.primaryIdentifier;
|
|
final event = identityParts.secondaryIdentifier;
|
|
var room = matrix.client.getRoomByAlias(roomIdOrAlias) ??
|
|
matrix.client.getRoomById(roomIdOrAlias);
|
|
var roomId = room?.id;
|
|
// we make the servers a set and later on convert to a list, so that we can easily
|
|
// deduplicate servers added via alias lookup and query parameter
|
|
final servers = <String>{};
|
|
if (room == null && roomIdOrAlias.sigil == '#') {
|
|
// we were unable to find the room locally...so resolve it
|
|
final response = await showFutureLoadingDialog(
|
|
context: context,
|
|
future: () => matrix.client.getRoomIdByAlias(roomIdOrAlias),
|
|
);
|
|
if (response.error != null) {
|
|
return; // nothing to do, the alias doesn't exist
|
|
}
|
|
roomId = response.result!.roomId;
|
|
servers.addAll(response.result!.servers!);
|
|
room = matrix.client.getRoomById(roomId!);
|
|
}
|
|
servers.addAll(identityParts.via);
|
|
if (room != null) {
|
|
if (room.isSpace) {
|
|
// TODO: Implement navigate to space
|
|
context.go('/rooms/${room.id}');
|
|
|
|
return;
|
|
}
|
|
// we have the room, so....just open it
|
|
if (event != null) {
|
|
context.go(
|
|
'/${Uri(
|
|
pathSegments: ['rooms', room.id],
|
|
queryParameters: {'event': event},
|
|
)}',
|
|
);
|
|
} else {
|
|
context.go('/rooms/${room.id}');
|
|
}
|
|
return;
|
|
} else {
|
|
await showAdaptiveDialog(
|
|
context: context,
|
|
builder: (c) => PublicRoomDialog(
|
|
roomAlias: identityParts.primaryIdentifier,
|
|
),
|
|
);
|
|
}
|
|
if (roomIdOrAlias.sigil == '!') {
|
|
if (await showOkCancelAlertDialog(
|
|
useRootNavigator: false,
|
|
context: context,
|
|
title: 'Join room $roomIdOrAlias',
|
|
) ==
|
|
OkCancelResult.ok) {
|
|
roomId = roomIdOrAlias;
|
|
final response = await showFutureLoadingDialog(
|
|
context: context,
|
|
future: () => matrix.client.joinRoom(
|
|
roomIdOrAlias,
|
|
serverName: servers.isNotEmpty ? servers.toList() : null,
|
|
),
|
|
);
|
|
if (response.error != null) return;
|
|
// wait for two seconds so that it probably came down /sync
|
|
await showFutureLoadingDialog(
|
|
context: context,
|
|
future: () => Future.delayed(const Duration(seconds: 2)),
|
|
);
|
|
if (event != null) {
|
|
context.go(
|
|
Uri(
|
|
pathSegments: ['rooms', response.result!],
|
|
queryParameters: {'event': event},
|
|
).toString(),
|
|
);
|
|
} else {
|
|
context.go('/rooms/${response.result!}');
|
|
}
|
|
}
|
|
}
|
|
} else if (identityParts.primaryIdentifier.sigil == '@') {
|
|
final userId = identityParts.primaryIdentifier;
|
|
var noProfileWarning = false;
|
|
final profileResult = await showFutureLoadingDialog(
|
|
context: context,
|
|
future: () => matrix.client.getProfileFromUserId(userId).catchError(
|
|
(_) {
|
|
noProfileWarning = true;
|
|
return Profile(userId: userId);
|
|
},
|
|
),
|
|
);
|
|
await UserDialog.show(
|
|
context: context,
|
|
profile: profileResult.result!,
|
|
noProfileWarning: noProfileWarning,
|
|
);
|
|
}
|
|
}
|
|
}
|