399 lines
12 KiB
Dart
399 lines
12 KiB
Dart
/*
|
|
* Copyright (c) 2024-2026 Fabian Freund.
|
|
*
|
|
* This file is part of WebLibre
|
|
* (see https://weblibre.eu).
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU Affero General Public License as
|
|
* published by the Free Software Foundation, either version 3 of the
|
|
* License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU Affero General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Affero General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
import 'package:flutter/material.dart';
|
|
import 'package:flutter_hooks/flutter_hooks.dart';
|
|
import 'package:flutter_mozilla_components/flutter_mozilla_components.dart';
|
|
import 'package:hooks_riverpod/hooks_riverpod.dart';
|
|
import 'package:weblibre/core/providers/router.dart';
|
|
import 'package:weblibre/domain/services/app_initialization.dart';
|
|
import 'package:weblibre/features/geckoview/domain/providers.dart';
|
|
import 'package:weblibre/features/sync/domain/entities/sync_repository_state.dart';
|
|
import 'package:weblibre/features/sync/domain/repositories/sync.dart';
|
|
import 'package:weblibre/features/web_search/domain/controllers/sandbox_capture_controller.dart';
|
|
import 'package:weblibre/presentation/widgets/failure_widget.dart';
|
|
import 'package:weblibre/utils/ui_helper.dart' as ui_helper;
|
|
|
|
class MainApp extends HookConsumerWidget {
|
|
final ThemeData? theme;
|
|
final ThemeData? darkTheme;
|
|
final ThemeMode? themeMode;
|
|
final double uiScaleFactor;
|
|
final bool disableAnimations;
|
|
|
|
const MainApp({
|
|
required this.theme,
|
|
required this.darkTheme,
|
|
required this.themeMode,
|
|
required this.uiScaleFactor,
|
|
required this.disableAnimations,
|
|
super.key,
|
|
});
|
|
|
|
@override
|
|
Widget build(BuildContext context, WidgetRef ref) {
|
|
final initializationResult = ref.watch(appInitializationServiceProvider);
|
|
final router = ref.watch(routerProvider);
|
|
|
|
return initializationResult.fold(
|
|
(initializationState) {
|
|
if (!initializationState.initialized) {
|
|
return MaterialApp(
|
|
debugShowCheckedModeBanner: false,
|
|
theme: theme,
|
|
darkTheme: darkTheme,
|
|
themeMode: themeMode,
|
|
themeAnimationStyle: disableAnimations
|
|
? AnimationStyle.noAnimation
|
|
: null,
|
|
builder: (context, child) {
|
|
return _AppMediaQueryOverrides(
|
|
uiScaleFactor: uiScaleFactor,
|
|
disableAnimations: disableAnimations,
|
|
child: child ?? const SizedBox.shrink(),
|
|
);
|
|
},
|
|
home: Scaffold(
|
|
body: Center(
|
|
child: Column(
|
|
mainAxisAlignment: MainAxisAlignment.center,
|
|
children: [
|
|
const CircularProgressIndicator(),
|
|
if (initializationState.stage != null)
|
|
Padding(
|
|
padding: const EdgeInsets.only(top: 8.0),
|
|
child: Text(initializationState.stage!),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
),
|
|
);
|
|
}
|
|
|
|
return MaterialApp.router(
|
|
debugShowCheckedModeBanner: false,
|
|
theme: theme,
|
|
darkTheme: darkTheme,
|
|
themeMode: themeMode,
|
|
themeAnimationStyle: disableAnimations
|
|
? AnimationStyle.noAnimation
|
|
: null,
|
|
routerConfig: router.value,
|
|
builder: (context, child) {
|
|
return _AppMediaQueryOverrides(
|
|
uiScaleFactor: uiScaleFactor,
|
|
disableAnimations: disableAnimations,
|
|
child: _SyncEventListener(
|
|
child: _SandboxCaptureErrorListener(
|
|
child: _DownloadStoppedListener(
|
|
child: _StrictContainerBlockListener(
|
|
child: child ?? const SizedBox.shrink(),
|
|
),
|
|
),
|
|
),
|
|
),
|
|
);
|
|
},
|
|
);
|
|
},
|
|
onFailure: (errorMessage) {
|
|
return MaterialApp(
|
|
debugShowCheckedModeBanner: false,
|
|
theme: theme,
|
|
darkTheme: darkTheme,
|
|
themeMode: themeMode,
|
|
themeAnimationStyle: disableAnimations
|
|
? AnimationStyle.noAnimation
|
|
: null,
|
|
builder: (context, child) {
|
|
return _AppMediaQueryOverrides(
|
|
uiScaleFactor: uiScaleFactor,
|
|
disableAnimations: disableAnimations,
|
|
child: child ?? const SizedBox.shrink(),
|
|
);
|
|
},
|
|
home: Scaffold(
|
|
appBar: AppBar(title: const Text('Initiallization Error')),
|
|
body: Center(
|
|
child: FailureWidget(
|
|
title: 'Could not initialize App',
|
|
exception: errorMessage.toString(),
|
|
onRetry: () async {
|
|
await ref
|
|
.read(appInitializationServiceProvider.notifier)
|
|
.reinitialize();
|
|
},
|
|
),
|
|
),
|
|
),
|
|
);
|
|
},
|
|
);
|
|
}
|
|
}
|
|
|
|
class _DownloadStoppedListener extends HookConsumerWidget {
|
|
final Widget child;
|
|
|
|
const _DownloadStoppedListener({required this.child});
|
|
|
|
@override
|
|
Widget build(BuildContext context, WidgetRef ref) {
|
|
final downloadStoppedEvents = ref.watch(
|
|
eventServiceProvider.select((service) => service.downloadStoppedEvents),
|
|
);
|
|
|
|
useOnStreamChange(
|
|
downloadStoppedEvents,
|
|
onData: (download) {
|
|
switch (download.status) {
|
|
case DownloadStatus.completed:
|
|
ui_helper.showInfoMessage(
|
|
context,
|
|
'Download completed',
|
|
duration: const Duration(seconds: 6),
|
|
action: SnackBarAction(
|
|
label: 'Open',
|
|
onPressed: () async {
|
|
final opened = await GeckoDownloadsService()
|
|
.openDownloadedFile(
|
|
fileName: download.fileName ?? '',
|
|
directoryPath: download.directoryPath ?? '',
|
|
contentType: download.contentType,
|
|
);
|
|
|
|
if (!opened && context.mounted) {
|
|
ui_helper.showErrorMessage(
|
|
context,
|
|
'Could not open downloaded file',
|
|
);
|
|
}
|
|
},
|
|
),
|
|
);
|
|
case DownloadStatus.failed:
|
|
ui_helper.showErrorMessage(
|
|
context,
|
|
'Download failed: ${download.fileName ?? download.url}',
|
|
persist: true,
|
|
);
|
|
case DownloadStatus.initiated:
|
|
case DownloadStatus.downloading:
|
|
case DownloadStatus.paused:
|
|
case DownloadStatus.cancelled:
|
|
case null:
|
|
break;
|
|
}
|
|
},
|
|
);
|
|
|
|
return child;
|
|
}
|
|
}
|
|
|
|
/// Surfaces a snackbar when the container-proxy extension cancels a navigation
|
|
/// because the active tab's container is in strict mode (only assigned sites
|
|
/// may load). Strict blocks carry no destination container — the load was
|
|
/// already cancelled natively — so this listener only notifies the user.
|
|
class _StrictContainerBlockListener extends HookConsumerWidget {
|
|
final Widget child;
|
|
|
|
const _StrictContainerBlockListener({required this.child});
|
|
|
|
@override
|
|
Widget build(BuildContext context, WidgetRef ref) {
|
|
final siteAssignmentEvents = ref.watch(
|
|
eventServiceProvider.select((service) => service.siteAssignementEvent),
|
|
);
|
|
|
|
useOnStreamChange(
|
|
siteAssignmentEvents,
|
|
onData: (event) {
|
|
if (!event.strict) {
|
|
return;
|
|
}
|
|
|
|
final host = Uri.tryParse(event.url)?.host;
|
|
ui_helper.showInfoMessage(
|
|
context,
|
|
host != null && host.isNotEmpty
|
|
? '$host is not assigned to this container'
|
|
: 'This site is not assigned to this container',
|
|
);
|
|
},
|
|
);
|
|
|
|
return child;
|
|
}
|
|
}
|
|
|
|
MediaQueryData applyAppMediaQueryOverrides({
|
|
required MediaQueryData mediaQuery,
|
|
required double uiScaleFactor,
|
|
required bool disableAnimations,
|
|
}) {
|
|
final textScaler = uiScaleFactor == 1.0
|
|
? mediaQuery.textScaler
|
|
: _AppTextScaler(
|
|
baseTextScaler: mediaQuery.textScaler,
|
|
uiScaleFactor: uiScaleFactor,
|
|
);
|
|
|
|
if (disableAnimations) {
|
|
return mediaQuery.copyWith(textScaler: textScaler, disableAnimations: true);
|
|
}
|
|
|
|
if (uiScaleFactor == 1.0) {
|
|
return mediaQuery;
|
|
}
|
|
|
|
return mediaQuery.copyWith(textScaler: textScaler);
|
|
}
|
|
|
|
class _AppMediaQueryOverrides extends StatelessWidget {
|
|
final double uiScaleFactor;
|
|
final bool disableAnimations;
|
|
final Widget child;
|
|
|
|
const _AppMediaQueryOverrides({
|
|
required this.uiScaleFactor,
|
|
required this.disableAnimations,
|
|
required this.child,
|
|
});
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
if (uiScaleFactor == 1.0 && !disableAnimations) {
|
|
return child;
|
|
}
|
|
|
|
final mediaQuery = MediaQuery.of(context);
|
|
final overriddenMediaQuery = applyAppMediaQueryOverrides(
|
|
mediaQuery: mediaQuery,
|
|
uiScaleFactor: uiScaleFactor,
|
|
disableAnimations: disableAnimations,
|
|
);
|
|
|
|
return MediaQuery(data: overriddenMediaQuery, child: child);
|
|
}
|
|
}
|
|
|
|
class _AppTextScaler extends TextScaler {
|
|
final TextScaler baseTextScaler;
|
|
final double uiScaleFactor;
|
|
|
|
const _AppTextScaler({
|
|
required this.baseTextScaler,
|
|
required this.uiScaleFactor,
|
|
}) : assert(uiScaleFactor > 0);
|
|
|
|
@override
|
|
double scale(double fontSize) =>
|
|
baseTextScaler.scale(fontSize) * uiScaleFactor;
|
|
|
|
@override
|
|
double get textScaleFactor => scale(1.0);
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (identical(this, other)) {
|
|
return true;
|
|
}
|
|
|
|
return other is _AppTextScaler &&
|
|
baseTextScaler == other.baseTextScaler &&
|
|
uiScaleFactor == other.uiScaleFactor;
|
|
}
|
|
|
|
@override
|
|
int get hashCode => Object.hash(baseTextScaler, uiScaleFactor);
|
|
}
|
|
|
|
class _SandboxCaptureErrorListener extends ConsumerWidget {
|
|
final Widget child;
|
|
|
|
const _SandboxCaptureErrorListener({required this.child});
|
|
|
|
@override
|
|
Widget build(BuildContext context, WidgetRef ref) {
|
|
ref.listen(sandboxCaptureErrorsProvider, (previous, next) {
|
|
final error = next.value;
|
|
if (error == null) return;
|
|
final message = switch (error.kind) {
|
|
SandboxCaptureErrorKind.insufficientCredits =>
|
|
error.detail ??
|
|
'You have no search credits left. Purchase more to continue.',
|
|
SandboxCaptureErrorKind.tokenIssuanceFailed =>
|
|
error.detail ??
|
|
'Could not issue new search tokens. Check your connection and try again.',
|
|
SandboxCaptureErrorKind.fetchPolicyRejected =>
|
|
'Capture blocked by fetch policy: ${error.detail ?? 'not allowed'}',
|
|
SandboxCaptureErrorKind.captureFailed =>
|
|
'Capture failed: ${error.detail ?? 'unknown error'}',
|
|
SandboxCaptureErrorKind.downloadFailed =>
|
|
'Capture artifact download failed.',
|
|
SandboxCaptureErrorKind.unknown =>
|
|
'Sandbox capture error: ${error.detail ?? 'unknown error'}',
|
|
};
|
|
ui_helper.showErrorMessage(context, message);
|
|
});
|
|
|
|
return child;
|
|
}
|
|
}
|
|
|
|
class _SyncEventListener extends ConsumerWidget {
|
|
final Widget child;
|
|
|
|
const _SyncEventListener({required this.child});
|
|
|
|
@override
|
|
Widget build(BuildContext context, WidgetRef ref) {
|
|
ref.listen(syncEventProvider, (previous, next) {
|
|
if (next.isLoading || !next.hasValue) return;
|
|
|
|
final event = next.value;
|
|
if (event == null) return;
|
|
|
|
final (syncEvent, syncError) = event;
|
|
|
|
switch (syncEvent) {
|
|
// case SyncEvent.completed:
|
|
// ui_helper.showInfoMessage(
|
|
// context,
|
|
// 'Synchronization complete',
|
|
// duration: const Duration(seconds: 2),
|
|
// );
|
|
case SyncEvent.error:
|
|
ui_helper.showErrorMessage(
|
|
context,
|
|
syncError ?? 'Synchronization failed',
|
|
);
|
|
case SyncEvent.started:
|
|
case SyncEvent.completed:
|
|
case null:
|
|
break;
|
|
}
|
|
});
|
|
|
|
return child;
|
|
}
|
|
}
|