Skip to content

armgit / ente

Public Imported from GitHub
0

πŸ’š End-to-end encrypted cloud for everything.

[mob][locker] Add in-app PDF viewer behind the internal flag (#13755)

aman-pilot3937f4cdcec1
diff --git a/mobile/apps/locker/ios/Podfile.lock b/mobile/apps/locker/ios/Podfile.lock
index 527d947326..4a0975fc99 100644
--- a/mobile/apps/locker/ios/Podfile.lock
+++ b/mobile/apps/locker/ios/Podfile.lock
@@ -40,6 +40,8 @@ PODS:
- Flutter
- ente_mail (0.0.1):
- Flutter
+ - ente_pdf_renderer (0.0.1):
+ - Flutter
- ente_screen_cover (0.0.1):
- Flutter
- EnteOnnxRuntime (1.28.1-r1)
@@ -122,6 +124,7 @@ DEPENDENCIES:
- device_info_plus (from `.symlinks/plugins/device_info_plus/ios`)
- ente_locker_frb (from `.symlinks/plugins/ente_locker_frb/ios`)
- ente_mail (from `.symlinks/plugins/ente_mail/ios`)
+ - ente_pdf_renderer (from `.symlinks/plugins/ente_pdf_renderer/ios`)
- ente_screen_cover (from `.symlinks/plugins/ente_screen_cover/ios`)
- EnteOnnxRuntime (from `../../../../apple/packages/EnteOnnxRuntime/EnteOnnxRuntime.podspec`)
- file_picker (from `.symlinks/plugins/file_picker/ios`)
@@ -164,6 +167,8 @@ EXTERNAL SOURCES:
:path: ".symlinks/plugins/ente_locker_frb/ios"
ente_mail:
:path: ".symlinks/plugins/ente_mail/ios"
+ ente_pdf_renderer:
+ :path: ".symlinks/plugins/ente_pdf_renderer/ios"
ente_screen_cover:
:path: ".symlinks/plugins/ente_screen_cover/ios"
EnteOnnxRuntime:
@@ -215,6 +220,7 @@ SPEC CHECKSUMS:
DKPhotoGallery: b3834fecb755ee09a593d7c9e389d8b5d6deed60
ente_locker_frb: 4509a99affb6399cec6d61bcf7af9676063b091d
ente_mail: f0569c7ea17e8324ef28f36a93c49fa1f3de724f
+ ente_pdf_renderer: aaf425420589887ef3aeab27344ccba3cb820d2f
ente_screen_cover: 6792566774f1c83939f9c1d03ed0a1f1ded45ae4
EnteOnnxRuntime: 7baa83a95717a6c9c8d0d4599f9f2c90b72d2905
file_picker: a0560bc09d61de87f12d246fc47d2119e6ef37be
diff --git a/mobile/apps/locker/lib/services/feature_flag_service.dart b/mobile/apps/locker/lib/services/feature_flag_service.dart
index 3d478eb8dc..51f547655c 100644
--- a/mobile/apps/locker/lib/services/feature_flag_service.dart
+++ b/mobile/apps/locker/lib/services/feature_flag_service.dart
@@ -17,6 +17,7 @@ class FeatureFlagService {
bool get internalUser => _flagService.internalUser;
bool get multipartUpload => internalUser;
+ bool get pdfViewer => internalUser;
bool get isInternalUserDisabled =>
_preferences.getBool(_internalUserDisabled) ?? false;
diff --git a/mobile/apps/locker/lib/ui/pages/pdf_viewer_page.dart b/mobile/apps/locker/lib/ui/pages/pdf_viewer_page.dart
new file mode 100644
index 0000000000..c513173e6d
--- /dev/null
+++ b/mobile/apps/locker/lib/ui/pages/pdf_viewer_page.dart
@@ -0,0 +1,565 @@
+import "dart:async";
+import "dart:io";
+
+import "package:ente_components/ente_components.dart";
+import "package:ente_pdf_renderer/ente_pdf_renderer.dart";
+import "package:ente_strings/ente_strings.dart";
+import "package:flutter/foundation.dart";
+import "package:flutter/material.dart";
+import "package:hugeicons/hugeicons.dart";
+import "package:locker/ui/viewer/pdf_page_layout.dart";
+import "package:logging/logging.dart";
+
+typedef PdfViewerAction = Future<void> Function(BuildContext);
+
+enum _Status { loading, ready, locked, unsupported, failed }
+
+class PdfViewerPage extends StatefulWidget {
+ const PdfViewerPage({
+ super.key,
+ required this.localFile,
+ required this.fileName,
+ required this.onOpenExternally,
+ this.onDownload,
+ this.onShare,
+ });
+
+ final File localFile;
+ final String fileName;
+ final PdfViewerAction onOpenExternally;
+ final PdfViewerAction? onDownload;
+ final PdfViewerAction? onShare;
+
+ @override
+ State<PdfViewerPage> createState() => _PdfViewerPageState();
+}
+
+class _PdfViewerPageState extends State<PdfViewerPage> {
+ static final _logger = Logger("PdfViewerPage");
+ static const _maxScale = 5.0;
+ static const _doubleTapScale = 2.5;
+ static const _maxRenderPixels = 8 * 1024 * 1024;
+
+ final _transformation = TransformationController();
+ final _currentPage = ValueNotifier(1);
+ final _password = TextEditingController();
+ final _tiles = <int, (MemoryImage, int)>{};
+ final _queue = <int>{};
+ final _failed = <int>{};
+
+ EntePdfDocument? _document;
+ PdfPageLayout? _layout;
+ _Status _status = _Status.loading;
+ bool _wrongPassword = false;
+ int _renderScale = 1;
+ double _pixelRatio = 1;
+ bool _rendering = false;
+ bool _toolbarVisible = true;
+ Offset _doubleTapAt = Offset.zero;
+
+ @override
+ void initState() {
+ super.initState();
+ _transformation.addListener(_updateCurrentPage);
+ unawaited(_open(null));
+ }
+
+ @override
+ void dispose() {
+ _transformation.dispose();
+ _currentPage.dispose();
+ _password.dispose();
+ _evictTiles();
+ unawaited(_document?.close());
+ super.dispose();
+ }
+
+ Future<void> _open(String? password) async {
+ setState(() {
+ _status = _Status.loading;
+ _wrongPassword = false;
+ });
+ try {
+ final document = await EntePdfRenderer.open(
+ widget.localFile.path,
+ password: password,
+ );
+ if (!mounted || document.pageCount == 0) {
+ await document.close();
+ if (mounted) setState(() => _status = _Status.failed);
+ return;
+ }
+ setState(() {
+ _document = document;
+ _status = _Status.ready;
+ });
+ } on PdfPasswordRequiredException {
+ if (mounted) setState(() => _status = _Status.locked);
+ } on PdfPasswordIncorrectException {
+ _wrongPassword = true;
+ if (mounted) setState(() => _status = _Status.locked);
+ } on PdfPasswordUnsupportedException {
+ if (mounted) setState(() => _status = _Status.unsupported);
+ } catch (e, s) {
+ _logger.warning("Failed to open PDF", e, s);
+ if (mounted) setState(() => _status = _Status.failed);
+ }
+ }
+
+ void _evictTiles() {
+ for (final (image, _) in _tiles.values) {
+ unawaited(image.evict());
+ }
+ _tiles.clear();
+ _queue.clear();
+ _failed.clear();
+ }
+
+ PdfPageLayout _layoutFor(Size viewport) {
+ final current = _layout;
+ if (current?.viewportWidth != viewport.width) {
+ _evictTiles();
+ WidgetsBinding.instance.addPostFrameCallback((_) {
+ if (mounted) _transformation.value = Matrix4.identity();
+ });
+ } else if (current!.viewportHeight == viewport.height) {
+ return current;
+ }
+ final padding = MediaQuery.paddingOf(context);
+ return _layout = PdfPageLayout(
+ pageSizes: _document!.pageSizes,
+ viewportWidth: viewport.width,
+ viewportHeight: viewport.height,
+ topInset: padding.top + kToolbarHeight + Spacing.lg,
+ bottomPadding: Spacing.lg + padding.bottom,
+ );
+ }
+
+ int _wantedWidth(int index) => _layout!.renderWidth(
+ index,
+ pixelRatio: _pixelRatio,
+ scale: _renderScale,
+ maxPixels: _maxRenderPixels,
+ );
+
+ void _requestTiles(int first, int last) {
+ _tiles.removeWhere((index, tile) {
+ final far = index < first - 2 || index > last + 2;
+ if (far) unawaited(tile.$1.evict());
+ return far;
+ });
+ _queue.removeWhere((index) => index < first || index > last);
+ for (var index = first; index <= last; index++) {
+ if (_tiles[index]?.$2 != _wantedWidth(index) &&
+ !_failed.contains(index)) {
+ _queue.add(index);
+ }
+ }
+ if (!_rendering) unawaited(_drainQueue());
+ }
+
+ Future<void> _drainQueue() async {
+ _rendering = true;
+ while (_queue.isNotEmpty && mounted) {
+ final index = _queue.first;
+ _queue.remove(index);
+ final width = _wantedWidth(index);
+ if (_tiles[index]?.$2 == width) continue;
+ try {
+ final bytes = await _document!.render(
+ index + 1,
+ width: width,
+ height: _layout!.renderHeight(index, width),
+ );
+ if (!mounted) return;
+ unawaited(_tiles[index]?.$1.evict());
+ setState(() => _tiles[index] = (MemoryImage(bytes), width));
+ } catch (e, s) {
+ _logger.warning("Failed to render PDF page ${index + 1}", e, s);
+ if (mounted) setState(() => _failed.add(index));
+ }
+ }
+ _rendering = false;
+ }
+
+ void _updateCurrentPage() {
+ final layout = _layout;
+ if (layout == null) return;
+ final top = _transformation.toScene(Offset.zero).dy;
+ final bottom = _transformation.toScene(Offset(0, layout.viewportHeight)).dy;
+ _currentPage.value = layout.currentPage(top, bottom) + 1;
+ }
+
+ void _updateRenderScale() {
+ final scale = PdfPageLayout.zoomBucket(
+ _transformation.value.getMaxScaleOnAxis(),
+ maxScale: _maxScale,
+ );
+ if (scale != _renderScale) setState(() => _renderScale = scale);
+ }
+
+ void _toggleZoom() {
+ final layout = _layout!;
+ final zoomedIn = _transformation.value.getMaxScaleOnAxis() > 1.01;
+ final scale = zoomedIn ? 1.0 : _doubleTapScale;
+ final scene = _transformation.toScene(_doubleTapAt);
+ final x = (_doubleTapAt.dx - scene.dx * scale).clamp(
+ layout.viewportWidth * (1 - scale),
+ 0.0,
+ );
+ final y = layout.clampTranslationY(
+ _doubleTapAt.dy - scene.dy * scale,
+ scale,
+ );
+ _transformation.value = Matrix4.translationValues(x, y, 0)
+ ..scaleByDouble(scale, scale, 1, 1);
+ _updateRenderScale();
+ }
+
+ void _scrollBy(double direction) {
+ final layout = _layout!;
+ final matrix = _transformation.value.clone();
+ final translation = matrix.getTranslation();
+ final scale = matrix.getMaxScaleOnAxis();
+ final step = (layout.viewportHeight - kToolbarHeight) * 0.8;
+ final y = layout.clampTranslationY(translation.y - direction * step, scale);
+ matrix.setTranslationRaw(translation.x, y, 0);
+ _transformation.value = matrix;
+ }
+
+ @override
+ Widget build(BuildContext context) {
+ final ready = _status == _Status.ready;
+ final canHideToolbar = ready && !MediaQuery.accessibleNavigationOf(context);
+ return Scaffold(
+ backgroundColor: context.componentColors.backgroundBase,
+ extendBodyBehindAppBar: true,
+ appBar: _Toolbar(
+ visible: _toolbarVisible || !canHideToolbar,
+ fileName: widget.fileName,
+ onShare: widget.onShare,
+ onDownload: widget.onDownload,
+ onOpenExternally: widget.onOpenExternally,
+ ),
+ body: GestureDetector(
+ behavior: HitTestBehavior.opaque,
+ excludeFromSemantics: true,
+ onTap: canHideToolbar
+ ? () => setState(() => _toolbarVisible = !_toolbarVisible)
+ : null,
+ onDoubleTapDown: (details) => _doubleTapAt = details.localPosition,
+ onDoubleTap: ready ? _toggleZoom : null,
+ child: Stack(
+ children: [
+ Positioned.fill(child: _body()),
+ if (ready)
+ _PageIndicator(page: _currentPage, total: _document!.pageCount),
+ ],
+ ),
+ ),
+ );
+ }
+
+ Widget _body() {
+ final l10n = context.strings;
+ final openExternally = ButtonComponent(
+ label: l10n.openInAnotherApp,
+ onTap: () => widget.onOpenExternally(context),
+ );
+ switch (_status) {
+ case _Status.loading:
+ return const Center(child: LoadingComponent());
+ case _Status.failed:
+ return _Message(text: l10n.errorOpeningFile, action: openExternally);
+ case _Status.unsupported:
+ return _Message(
+ text: l10n.pdfPasswordNotSupportedOnDevice,
+ action: openExternally,
+ );
+ case _Status.locked:
+ return _Message(
+ text: l10n.pdfNeedsPassword,
+ field: TextInputComponent(
+ controller: _password,
+ label: l10n.password,
+ isPasswordInput: true,
+ autofocus: true,
+ autocorrect: false,
+ enableSuggestions: false,
+ textInputAction: TextInputAction.done,
+ message: _wrongPassword ? l10n.incorrectPasswordTitle : null,
+ messageType: TextInputComponentMessageType.error,
+ onSubmit: _open,
+ ),
+ action: ButtonComponent(
+ label: l10n.unlockPdf,
+ shouldSurfaceExecutionStates: false,
+ onTap: () => _open(_password.text),
+ ),
+ );
+ case _Status.ready:
+ return LayoutBuilder(
+ builder: (context, constraints) => _pages(constraints),
+ );
+ }
+ }
+
+ Widget _pages(BoxConstraints constraints) {
+ final layout = _layoutFor(constraints.biggest);
+ _pixelRatio = MediaQuery.devicePixelRatioOf(context);
+ return Semantics(
+ container: true,
+ onScrollUp: () => _scrollBy(-1),
+ onScrollDown: () => _scrollBy(1),
+ child: InteractiveViewer.builder(
+ transformationController: _transformation,
+ minScale: 1,
+ maxScale: _maxScale,
+ onInteractionEnd: (_) => _updateRenderScale(),
+ builder: (context, viewport) {
+ final (first, last) = layout.visibleRange(
+ viewport.point0.y,
+ viewport.point2.y,
+ margin: _renderScale == 1 ? 1 : 0,
+ );
+ _requestTiles(first, last);
+ return SizedBox(
+ width: layout.viewportWidth,
+ height: layout.contentHeight,
+ child: Stack(
+ children: [
+ for (var index = first; index <= last; index++)
+ Positioned(
+ key: ValueKey(index),
+ top: layout.pageTop(index),
+ left: PdfPageLayout.horizontalPadding,
+ width: layout.contentWidth,
+ height: layout.pageHeight(index),
+ child: RepaintBoundary(
+ child: _PageTile(
+ image: _tiles[index]?.$1,
+ failed: _failed.contains(index),
+ onOpenExternally: widget.onOpenExternally,
+ ),
+ ),
+ ),
+ ],
+ ),
+ );
+ },
+ ),
+ );
+ }
+}
+
+class _Toolbar extends StatelessWidget implements PreferredSizeWidget {
+ const _Toolbar({
+ required this.visible,
+ required this.fileName,
+ required this.onOpenExternally,
+ this.onShare,
+ this.onDownload,
+ });
+
+ final bool visible;
+ final String fileName;
+ final PdfViewerAction onOpenExternally;
+ final PdfViewerAction? onShare;
+ final PdfViewerAction? onDownload;
+
+ @override
+ Size get preferredSize => const Size.fromHeight(kToolbarHeight);
+
+ @override
+ Widget build(BuildContext context) {
+ final colors = context.componentColors;
+ final l10n = context.strings;
+ return AnimatedSlide(
+ offset: visible ? Offset.zero : const Offset(0, -1),
+ duration: MediaQuery.disableAnimationsOf(context)
+ ? Duration.zero
+ : const Duration(milliseconds: 180),
+ child: AppBar(
+ backgroundColor: colors.backgroundBase,
+ foregroundColor: colors.textBase,
+ surfaceTintColor: Colors.transparent,
+ elevation: 0,
+ scrolledUnderElevation: 0,
+ centerTitle: false,
+ actionsPadding: const EdgeInsetsDirectional.only(end: Spacing.sm),
+ leading: IconButtonComponent(
+ icon: const HugeIcon(icon: HugeIcons.strokeRoundedArrowLeft01),
+ variant: IconButtonComponentVariant.unfilled,
+ tooltip: MaterialLocalizations.of(context).backButtonTooltip,
+ onTap: () => Navigator.maybePop(context),
+ ),
+ title: Text(
+ fileName,
+ maxLines: 1,
+ overflow: TextOverflow.ellipsis,
+ style: TextStyles.display3.copyWith(color: colors.textBase),
+ ),
+ actions: [
+ if (onShare != null)
+ IconButtonComponent(
+ icon: const HugeIcon(icon: HugeIcons.strokeRoundedShare08),
+ variant: IconButtonComponentVariant.unfilled,
+ tooltip: l10n.shareLink,
+ shouldSurfaceExecutionStates: false,
+ onTap: () => onShare!(context),
+ ),
+ Builder(
+ builder: (buttonContext) => IconButtonComponent(
+ icon: const HugeIcon(icon: HugeIcons.strokeRoundedMoreVertical),
+ variant: IconButtonComponentVariant.unfilled,
+ tooltip: l10n.more,
+ shouldSurfaceExecutionStates: false,
+ onTap: () => _showMenu(buttonContext),
+ ),
+ ),
+ ],
+ ),
+ );
+ }
+
+ Future<void> _showMenu(BuildContext context) async {
+ final l10n = context.strings;
+ final action = await showEntePopupMenu<PdfViewerAction>(
+ context: context,
+ options: [
+ if (onDownload != null)
+ EntePopupMenuOption(value: onDownload!, label: l10n.download),
+ EntePopupMenuOption(
+ value: onOpenExternally,
+ label: l10n.openInAnotherApp,
+ ),
+ ],
+ );
+ if (action != null && context.mounted) await action(context);
+ }
+}
+
+class _Message extends StatelessWidget {
+ const _Message({required this.text, required this.action, this.field});
+
+ final String text;
+ final Widget action;
+ final Widget? field;
+
+ @override
+ Widget build(BuildContext context) {
+ return Center(
+ child: SingleChildScrollView(
+ padding: EdgeInsets.fromLTRB(
+ Spacing.xxl,
+ MediaQuery.paddingOf(context).top + kToolbarHeight + Spacing.xxl,
+ Spacing.xxl,
+ Spacing.xxl,
+ ),
+ child: Column(
+ mainAxisSize: MainAxisSize.min,
+ crossAxisAlignment: CrossAxisAlignment.stretch,
+ children: [
+ Text(
+ text,
+ textAlign: TextAlign.center,
+ style: TextStyles.body.copyWith(
+ color: context.componentColors.textBase,
+ ),
+ ),
+ if (field != null) ...[const SizedBox(height: Spacing.xl), field!],
+ const SizedBox(height: Spacing.xl),
+ action,
+ ],
+ ),
+ ),
+ );
+ }
+}
+
+class _PageTile extends StatelessWidget {
+ const _PageTile({
+ required this.image,
+ required this.failed,
+ required this.onOpenExternally,
+ });
+
+ final MemoryImage? image;
+ final bool failed;
+ final PdfViewerAction onOpenExternally;
+
+ @override
+ Widget build(BuildContext context) {
+ final colors = context.componentColors;
+ return DecoratedBox(
+ decoration: BoxDecoration(
+ color: Colors.white,
+ boxShadow: [
+ BoxShadow(
+ color: colors.specialScrim.withValues(alpha: 0.2),
+ blurRadius: 4,
+ offset: const Offset(0, 1),
+ ),
+ ],
+ ),
+ child: failed
+ ? Center(
+ child: Column(
+ mainAxisSize: MainAxisSize.min,
+ children: [
+ Text(
+ context.strings.errorOpeningFile,
+ textAlign: TextAlign.center,
+ style: TextStyles.body.copyWith(color: colors.textBase),
+ ),
+ const SizedBox(height: Spacing.lg),
+ ButtonComponent(
+ label: context.strings.openInAnotherApp,
+ onTap: () => onOpenExternally(context),
+ ),
+ ],
+ ),
+ )
+ : image == null
+ ? null
+ : Image(image: image!, fit: BoxFit.fill, gaplessPlayback: true),
+ );
+ }
+}
+
+class _PageIndicator extends StatelessWidget {
+ const _PageIndicator({required this.page, required this.total});
+
+ final ValueListenable<int> page;
+ final int total;
+
+ @override
+ Widget build(BuildContext context) {
+ final colors = context.componentColors;
+ return Positioned(
+ right: Spacing.md,
+ bottom: Spacing.xl + MediaQuery.paddingOf(context).bottom,
+ child: ValueListenableBuilder<int>(
+ valueListenable: page,
+ builder: (context, page, _) => Container(
+ padding: const EdgeInsets.symmetric(
+ horizontal: Spacing.md,
+ vertical: Spacing.sm,
+ ),
+ decoration: BoxDecoration(
+ color: colors.fillDark,
+ borderRadius: BorderRadius.circular(Radii.lg),
+ ),
+ child: Text(
+ "$page / $total",
+ semanticsLabel: context.strings.scanPageOfTotal(
+ current: page,
+ total: total,
+ ),
+ style: TextStyles.mini.copyWith(color: colors.textLight),
+ ),
+ ),
+ ),
+ );
+ }
+}
diff --git a/mobile/apps/locker/lib/ui/viewer/pdf_page_layout.dart b/mobile/apps/locker/lib/ui/viewer/pdf_page_layout.dart
new file mode 100644
index 0000000000..0d414b1dc9
--- /dev/null
+++ b/mobile/apps/locker/lib/ui/viewer/pdf_page_layout.dart
@@ -0,0 +1,92 @@
+import "dart:math" as math;
+import "dart:ui";
+
+import "package:ente_components/ente_components.dart";
+
+class PdfPageLayout {
+ PdfPageLayout({
+ required this.pageSizes,
+ required this.viewportWidth,
+ required this.viewportHeight,
+ required this.topInset,
+ required this.bottomPadding,
+ }) : contentWidth = viewportWidth - horizontalPadding * 2,
+ offsets = List.filled(pageSizes.length + 1, topInset) {
+ for (var i = 0; i < pageSizes.length; i++) {
+ offsets[i + 1] = offsets[i] + contentWidth / _aspect(pageSizes[i]) + gap;
+ }
+ }
+
+ static const horizontalPadding = Spacing.lg;
+ static const gap = Spacing.md;
+ static const _fallbackAspect = 1 / 1.414;
+
+ final List<Size> pageSizes;
+ final double viewportWidth;
+ final double viewportHeight;
+ final double topInset;
+ final double bottomPadding;
+ final double contentWidth;
+ final List<double> offsets;
+
+ int get pageCount => pageSizes.length;
+
+ double get contentHeight =>
+ math.max(viewportHeight, offsets.last - gap + bottomPadding);
+
+ static double _aspect(Size size) {
+ final aspect = size.width / size.height;
+ return aspect.isFinite && aspect > 0 ? aspect : _fallbackAspect;
+ }
+
+ double pageTop(int index) => offsets[index];
+
+ double pageHeight(int index) => offsets[index + 1] - offsets[index] - gap;
+
+ int pageAt(double y) {
+ final index = offsets.lastIndexWhere((offset) => offset <= y);
+ return index.clamp(0, pageCount - 1);
+ }
+
+ int currentPage(double top, double bottom) {
+ var best = pageAt(top);
+ var bestFraction = -1.0;
+ for (var index = best; index <= pageAt(bottom); index++) {
+ final height = pageHeight(index);
+ final pageBottom = pageTop(index) + height;
+ final visible =
+ math.min(bottom, pageBottom) - math.max(top, pageTop(index));
+ if (visible / height > bestFraction) {
+ best = index;
+ bestFraction = visible / height;
+ }
+ }
+ return best;
+ }
+
+ (int, int) visibleRange(double top, double bottom, {int margin = 1}) {
+ final first = math.max(0, pageAt(top) - margin);
+ final last = math.min(pageCount - 1, pageAt(bottom) + margin);
+ return (first, last);
+ }
+
+ double clampTranslationY(double y, double scale) =>
+ y.clamp(viewportHeight - contentHeight * scale, 0.0);
+
+ int renderWidth(
+ int index, {
+ required double pixelRatio,
+ required int scale,
+ required int maxPixels,
+ }) {
+ final wanted = contentWidth * pixelRatio * scale;
+ final capped = math.sqrt(maxPixels * _aspect(pageSizes[index]));
+ return math.max(1, math.min(wanted, capped).round());
+ }
+
+ int renderHeight(int index, int width) =>
+ math.max(1, (width / _aspect(pageSizes[index])).round());
+
+ static int zoomBucket(double scale, {required double maxScale}) =>
+ scale.clamp(1.0, maxScale).ceil();
+}
diff --git a/mobile/apps/locker/lib/utils/file_util.dart b/mobile/apps/locker/lib/utils/file_util.dart
index 8134310aab..17b0818390 100644
--- a/mobile/apps/locker/lib/utils/file_util.dart
+++ b/mobile/apps/locker/lib/utils/file_util.dart
@@ -9,19 +9,24 @@ import "package:file_saver/file_saver.dart";
import "package:flutter/material.dart";
import "package:locker/models/info/info_item.dart";
import "package:locker/services/collections/collections_service.dart";
+import "package:locker/services/configuration.dart";
+import "package:locker/services/feature_flag_service.dart";
import "package:locker/services/files/download/file_downloader.dart"
as file_downloader;
import "package:locker/services/files/offline/offline_file_storage.dart";
import "package:locker/services/files/sync/models/file.dart";
import "package:locker/services/info_file_service.dart";
+import "package:locker/services/trash/models/trash_file.dart";
import 'package:locker/ui/components/locker_progress_dialog.dart';
import "package:locker/ui/pages/account_credentials_page.dart";
import "package:locker/ui/pages/base_info_page.dart";
import "package:locker/ui/pages/emergency_contact_page.dart";
+import "package:locker/ui/pages/pdf_viewer_page.dart";
import "package:locker/ui/pages/personal_note_page.dart";
import "package:locker/ui/pages/physical_records_page.dart";
import "package:locker/utils/bottom_sheet_illustration.dart";
import "package:locker/utils/error_sheet.dart";
+import "package:locker/utils/file_actions.dart";
import "package:logging/logging.dart";
import "package:open_file/open_file.dart";
import "package:path/path.dart" as p;
@@ -32,21 +37,6 @@ class FileUtil {
static Future<void> openFile(BuildContext context, EnteFile file) async {
final l10n = context.strings;
- Future<void> showOpenFileError({
- required String error,
- ResultType? resultType,
- }) async {
- if (!context.mounted) {
- return;
- }
- await _showOpenFileError(
- context,
- error: error,
- resultType: resultType,
- lockerFile: file,
- );
- }
-
if (InfoFileService.instance.isInfoFile(file)) {
return _openInfoFile(context, file);
}
@@ -60,11 +50,10 @@ class FileUtil {
if (await cachedDecryptedFile.exists()) {
final cachedSize = await cachedDecryptedFile.length();
if (cachedSize > 0) {
- await _launchFile(
+ await _openDecryptedFile(
+ context.mounted ? context : null,
cachedDecryptedFile,
- displayName: file.displayName,
- lockerFile: file,
- showError: showOpenFileError,
+ file,
);
return;
}
@@ -100,11 +89,10 @@ class FileUtil {
await dialog?.hide();
if (decryptedFile != null) {
- await _launchFile(
+ await _openDecryptedFile(
+ context.mounted ? context : null,
decryptedFile,
- displayName: file.displayName,
- lockerFile: file,
- showError: showOpenFileError,
+ file,
);
} else if (context.mounted) {
await showBottomSheetComponent(
@@ -402,6 +390,64 @@ class FileUtil {
}
}
+ static Future<void> _openDecryptedFile(
+ BuildContext? context,
+ File localFile,
+ EnteFile file,
+ ) async {
+ final extension = getPreferredFileExtension(
+ file,
+ fallbackPath: localFile.path,
+ ).toLowerCase();
+ if (context == null ||
+ !context.mounted ||
+ extension != ".pdf" ||
+ !FeatureFlagService.instance.pdfViewer) {
+ return _openExternally(context, localFile, file);
+ }
+ final canShare =
+ file is! TrashFile &&
+ file.ownerID == Configuration.instance.getUserID();
+ await Navigator.of(context).push(
+ MaterialPageRoute(
+ builder: (_) => PdfViewerPage(
+ localFile: localFile,
+ fileName: file.displayName,
+ onOpenExternally: (viewerContext) =>
+ _openExternally(viewerContext, localFile, file),
+ onDownload: (viewerContext) => downloadFile(viewerContext, file),
+ onShare: canShare
+ ? (viewerContext) =>
+ FileActions.shareFileLink(viewerContext, file)
+ : null,
+ ),
+ ),
+ );
+ }
+
+ static Future<void> _openExternally(
+ BuildContext? context,
+ File localFile,
+ EnteFile file,
+ ) {
+ return _launchFile(
+ localFile,
+ displayName: file.displayName,
+ lockerFile: file,
+ showError: ({required error, resultType}) async {
+ if (context == null || !context.mounted) {
+ return;
+ }
+ await _showOpenFileError(
+ context,
+ error: error,
+ resultType: resultType,
+ lockerFile: file,
+ );
+ },
+ );
+ }
+
static Future<void> _launchFile(
File file, {
String? displayName,
diff --git a/mobile/apps/locker/pubspec.yaml b/mobile/apps/locker/pubspec.yaml
index c3f8ef50c7..05ba6fe548 100644
--- a/mobile/apps/locker/pubspec.yaml
+++ b/mobile/apps/locker/pubspec.yaml
@@ -52,6 +52,8 @@ dependencies:
path: ../../packages/logging
ente_network:
path: ../../packages/network
+ ente_pdf_renderer:
+ path: ../../packages/ente_pdf_renderer
ente_pure_utils:
path: ../../packages/ente_pure_utils
ente_sharing:
diff --git a/mobile/apps/locker/test/ui/pages/pdf_viewer_page_test.dart b/mobile/apps/locker/test/ui/pages/pdf_viewer_page_test.dart
new file mode 100644
index 0000000000..a8a4cfe207
--- /dev/null
+++ b/mobile/apps/locker/test/ui/pages/pdf_viewer_page_test.dart
@@ -0,0 +1,132 @@
+import "dart:convert";
+import "dart:io";
+
+import "package:ente_components/ente_components.dart";
+import "package:ente_strings/ente_strings.dart";
+import "package:flutter/material.dart";
+import "package:flutter/services.dart";
+import "package:flutter_test/flutter_test.dart";
+import "package:locker/ui/pages/pdf_viewer_page.dart";
+
+void main() {
+ const channel = MethodChannel("io.ente/pdf_renderer");
+ final png = base64Decode(
+ "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+ip1sAAAAASUVORK5CYII=",
+ );
+ final calls = <MethodCall>[];
+ var pageCount = 1;
+ var pageSize = const Size(595, 842);
+ var failRender = false;
+ var openedExternally = 0;
+
+ setUp(() {
+ calls.clear();
+ pageCount = 1;
+ pageSize = const Size(595, 842);
+ failRender = false;
+ openedExternally = 0;
+ TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger
+ .setMockMethodCallHandler(channel, (call) async {
+ calls.add(call);
+ switch (call.method) {
+ case "open":
+ return {
+ "id": 1,
+ "widths": List.filled(pageCount, pageSize.width),
+ "heights": List.filled(pageCount, pageSize.height),
+ };
+ case "render":
+ if (failRender) {
+ throw PlatformException(code: "invalid", message: "boom");
+ }
+ return png;
+ default:
+ return null;
+ }
+ });
+ });
+
+ tearDown(() {
+ TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger
+ .setMockMethodCallHandler(channel, null);
+ });
+
+ Future<void> pumpViewer(WidgetTester tester) async {
+ await tester.pumpWidget(
+ MaterialApp(
+ theme: ComponentTheme.lightTheme(app: ComponentApp.locker),
+ localizationsDelegates: StringsLocalizations.localizationsDelegates,
+ supportedLocales: const [Locale("en")],
+ home: PdfViewerPage(
+ localFile: File("/tmp/sample.pdf"),
+ fileName: "sample.pdf",
+ onOpenExternally: (_) async => openedExternally++,
+ ),
+ ),
+ );
+ await tester.pumpAndSettle();
+ }
+
+ Future<void> doubleTapAt(WidgetTester tester, Offset position) async {
+ await tester.tapAt(position);
+ await tester.pump(const Duration(milliseconds: 60));
+ await tester.tapAt(position);
+ await tester.pumpAndSettle();
+ }
+
+ testWidgets("a PDF with no pages shows the error state", (tester) async {
+ pageCount = 0;
+ await pumpViewer(tester);
+ expect(find.text("Error opening item"), findsOneWidget);
+ expect(calls.map((call) => call.method), ["open", "close"]);
+ });
+
+ testWidgets("a page that fails to render offers the external app", (
+ tester,
+ ) async {
+ failRender = true;
+ pageSize = const Size(842, 595);
+ await pumpViewer(tester);
+
+ expect(find.text("Error opening item"), findsOneWidget);
+ await tester.tap(find.text("Open in another app"));
+ await tester.pump(const Duration(milliseconds: 400));
+ expect(openedExternally, 1);
+ });
+
+ testWidgets("double tap zooms around the tap and zooming out keeps place", (
+ tester,
+ ) async {
+ pageCount = 6;
+ await pumpViewer(tester);
+ final viewer = find.byType(InteractiveViewer);
+ final controller = tester
+ .widget<InteractiveViewer>(viewer)
+ .transformationController!;
+
+ await tester.drag(viewer, const Offset(0, -2000));
+ await tester.pumpAndSettle();
+ final scrolled = controller.value.getTranslation().y;
+ expect(scrolled, lessThan(-1500));
+
+ final center = tester.getCenter(viewer);
+ await doubleTapAt(tester, center);
+ expect(controller.value.getMaxScaleOnAxis(), closeTo(2.5, 0.001));
+ final focus = controller.toScene(center);
+
+ await doubleTapAt(tester, center);
+ expect(controller.value.getMaxScaleOnAxis(), closeTo(1, 0.001));
+ expect(controller.toScene(center).dy, closeTo(focus.dy, 0.5));
+ expect(controller.value.getTranslation().y, closeTo(scrolled, 0.5));
+ });
+
+ testWidgets("closes the document when the viewer is disposed", (
+ tester,
+ ) async {
+ await pumpViewer(tester);
+ calls.clear();
+ await tester.pumpWidget(const SizedBox());
+ await tester.pumpAndSettle();
+ expect(calls.map((call) => call.method), ["close"]);
+ });
+}
diff --git a/mobile/apps/locker/test/ui/viewer/pdf_page_layout_test.dart b/mobile/apps/locker/test/ui/viewer/pdf_page_layout_test.dart
new file mode 100644
index 0000000000..ae2e76cc0d
--- /dev/null
+++ b/mobile/apps/locker/test/ui/viewer/pdf_page_layout_test.dart
@@ -0,0 +1,103 @@
+import "dart:ui";
+
+import "package:flutter_test/flutter_test.dart";
+import "package:locker/ui/viewer/pdf_page_layout.dart";
+
+void main() {
+ PdfPageLayout layout(List<Size> pages, {double viewportHeight = 800}) {
+ return PdfPageLayout(
+ pageSizes: pages,
+ viewportWidth: 400,
+ viewportHeight: viewportHeight,
+ topInset: 100,
+ bottomPadding: 20,
+ );
+ }
+
+ test("stacks pages at content width with gaps and insets", () {
+ final pages = layout(const [Size(100, 200), Size(200, 100)]);
+ expect(pages.contentWidth, 368);
+ expect(pages.offsets, [100, 848, 1044]);
+ expect(pages.pageHeight(0), 736);
+ expect(pages.pageHeight(1), 184);
+ expect(pages.contentHeight, 1052);
+ });
+
+ test("content height never drops below the viewport", () {
+ final single = layout(const [Size(200, 100)], viewportHeight: 900);
+ expect(single.contentHeight, 900);
+ });
+
+ test("invalid page sizes fall back to an A4 aspect", () {
+ final broken = layout(const [Size(0, 0), Size(100, double.infinity)]);
+ expect(broken.pageHeight(0), closeTo(368 * 1.414, 0.01));
+ expect(broken.pageHeight(1), closeTo(368 * 1.414, 0.01));
+ });
+
+ test("pageAt resolves boundaries and out-of-range positions", () {
+ final pages = layout(const [Size(1, 1), Size(1, 1), Size(1, 1)]);
+ expect(pages.offsets, [100, 480, 860, 1240]);
+ expect(pages.pageAt(-50), 0);
+ expect(pages.pageAt(479.9), 0);
+ expect(pages.pageAt(480), 1);
+ expect(pages.pageAt(859.9), 1);
+ expect(pages.pageAt(860), 2);
+ expect(pages.pageAt(99999), 2);
+ });
+
+ test("visibleRange adds the margin and clamps to the document", () {
+ final pages = layout(List.filled(10, const Size(1, 1)));
+ expect(pages.visibleRange(0, 10), (0, 1));
+ expect(pages.visibleRange(1300, 1500), (2, 4));
+ expect(pages.visibleRange(3500, 99999), (7, 9));
+ expect(pages.visibleRange(1300, 1500, margin: 0), (3, 3));
+ });
+
+ test("currentPage is the page with the largest visible fraction", () {
+ final pages = layout(const [Size(1, 2.5), Size(4, 1)]);
+ expect(pages.offsets, [100, 1032, 1136]);
+ expect(pages.currentPage(0, 800), 0);
+ expect(pages.currentPage(344, 1144), 1);
+
+ final equal = layout(List.filled(3, const Size(1, 1)));
+ expect(equal.currentPage(0, 800), 0);
+ expect(equal.currentPage(300, 1100), 1);
+ expect(equal.currentPage(700, 1500), 2);
+ });
+
+ test("clampTranslationY keeps the content inside the viewport", () {
+ final pages = layout(const [Size(100, 200), Size(200, 100)]);
+ expect(pages.clampTranslationY(10, 1), 0);
+ expect(pages.clampTranslationY(-500, 1), -252);
+ expect(pages.clampTranslationY(-1500, 2), -1304);
+ });
+
+ test("renderWidth follows pixel ratio and zoom until the pixel cap", () {
+ final pages = layout(const [Size(100, 200), Size(400, 100)]);
+ expect(
+ pages.renderWidth(0, pixelRatio: 3, scale: 1, maxPixels: 100000000),
+ 1104,
+ );
+ expect(
+ pages.renderWidth(0, pixelRatio: 3, scale: 4, maxPixels: 100000000),
+ 4416,
+ );
+ final capped = pages.renderWidth(
+ 0,
+ pixelRatio: 3,
+ scale: 4,
+ maxPixels: 8000000,
+ );
+ expect(capped, 2000);
+ expect(pages.renderHeight(0, capped), 4000);
+ expect(pages.renderHeight(1, 400), 100);
+ });
+
+ test("zoom buckets round up within the scale range", () {
+ expect(PdfPageLayout.zoomBucket(0.5, maxScale: 5), 1);
+ expect(PdfPageLayout.zoomBucket(1, maxScale: 5), 1);
+ expect(PdfPageLayout.zoomBucket(1.2, maxScale: 5), 2);
+ expect(PdfPageLayout.zoomBucket(4.01, maxScale: 5), 5);
+ expect(PdfPageLayout.zoomBucket(9, maxScale: 5), 5);
+ });
+}
diff --git a/mobile/packages/ente_pdf_renderer/.gitignore b/mobile/packages/ente_pdf_renderer/.gitignore
new file mode 100644
index 0000000000..a8c7d1d6fe
--- /dev/null
+++ b/mobile/packages/ente_pdf_renderer/.gitignore
@@ -0,0 +1,2 @@
+.dart_tool/
+build/
diff --git a/mobile/packages/ente_pdf_renderer/android/build.gradle b/mobile/packages/ente_pdf_renderer/android/build.gradle
new file mode 100644
index 0000000000..697a94a415
--- /dev/null
+++ b/mobile/packages/ente_pdf_renderer/android/build.gradle
@@ -0,0 +1,15 @@
+plugins {
+ id 'com.android.library'
+ id 'org.jetbrains.kotlin.android'
+}
+
+group 'io.ente.pdf_renderer'
+version '1.0'
+
+android {
+ namespace 'io.ente.pdf_renderer'
+
+ defaultConfig {
+ minSdkVersion 21
+ }
+}
diff --git a/mobile/packages/ente_pdf_renderer/android/src/main/AndroidManifest.xml b/mobile/packages/ente_pdf_renderer/android/src/main/AndroidManifest.xml
new file mode 100644
index 0000000000..94cbbcfc39
--- /dev/null
+++ b/mobile/packages/ente_pdf_renderer/android/src/main/AndroidManifest.xml
@@ -0,0 +1 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android" />
diff --git a/mobile/packages/ente_pdf_renderer/android/src/main/kotlin/io/ente/pdf_renderer/EntePdfRendererPlugin.kt b/mobile/packages/ente_pdf_renderer/android/src/main/kotlin/io/ente/pdf_renderer/EntePdfRendererPlugin.kt
new file mode 100644
index 0000000000..9d4624ff2d
--- /dev/null
+++ b/mobile/packages/ente_pdf_renderer/android/src/main/kotlin/io/ente/pdf_renderer/EntePdfRendererPlugin.kt
@@ -0,0 +1,131 @@
+package io.ente.pdf_renderer
+
+import android.graphics.Bitmap
+import android.graphics.Color
+import android.graphics.pdf.LoadParams
+import android.graphics.pdf.PdfRenderer
+import android.graphics.pdf.RenderParams
+import android.os.Build
+import android.os.Handler
+import android.os.Looper
+import android.os.ParcelFileDescriptor
+import io.flutter.embedding.engine.plugins.FlutterPlugin
+import io.flutter.plugin.common.MethodCall
+import io.flutter.plugin.common.MethodChannel
+import java.io.ByteArrayOutputStream
+import java.io.File
+import java.util.concurrent.Executors
+
+class EntePdfRendererPlugin : FlutterPlugin, MethodChannel.MethodCallHandler {
+ private class PdfError(val code: String, message: String) : Exception(message)
+
+ private lateinit var channel: MethodChannel
+ private val documents = HashMap<Int, PdfRenderer>()
+ private var nextId = 1
+ private val executor = Executors.newSingleThreadExecutor()
+ private val mainThread = Handler(Looper.getMainLooper())
+ private val supportsPasswords = Build.VERSION.SDK_INT >= Build.VERSION_CODES.VANILLA_ICE_CREAM
+
+ override fun onAttachedToEngine(binding: FlutterPlugin.FlutterPluginBinding) {
+ channel = MethodChannel(binding.binaryMessenger, "io.ente/pdf_renderer")
+ channel.setMethodCallHandler(this)
+ }
+
+ override fun onDetachedFromEngine(binding: FlutterPlugin.FlutterPluginBinding) {
+ channel.setMethodCallHandler(null)
+ executor.execute {
+ documents.values.forEach { it.close() }
+ documents.clear()
+ }
+ executor.shutdown()
+ }
+
+ override fun onMethodCall(call: MethodCall, result: MethodChannel.Result) {
+ executor.execute {
+ try {
+ val reply: Any? = when (call.method) {
+ "open" -> open(call.argument<String>("path")!!, call.argument<String>("password"))
+ "render" -> render(
+ call.argument<Int>("id")!!,
+ call.argument<Int>("page")!!,
+ call.argument<Int>("width")!!,
+ call.argument<Int>("height")!!,
+ )
+ "close" -> {
+ documents.remove(call.argument<Int>("id")!!)?.close()
+ null
+ }
+ else -> {
+ mainThread.post { result.notImplemented() }
+ return@execute
+ }
+ }
+ mainThread.post { result.success(reply) }
+ } catch (e: PdfError) {
+ mainThread.post { result.error(e.code, e.message, null) }
+ } catch (e: Exception) {
+ mainThread.post { result.error("invalid", e.toString(), null) }
+ }
+ }
+ }
+
+ private fun open(path: String, password: String?): Map<String, Any> {
+ val descriptor = ParcelFileDescriptor.open(File(path), ParcelFileDescriptor.MODE_READ_ONLY)
+ val renderer = try {
+ if (supportsPasswords && password != null) {
+ PdfRenderer(descriptor, LoadParams.Builder().setPassword(password).build())
+ } else {
+ PdfRenderer(descriptor)
+ }
+ } catch (e: Exception) {
+ descriptor.close()
+ when {
+ e !is SecurityException -> throw e
+ !supportsPasswords -> throw PdfError("password_unsupported", "This device cannot unlock PDFs")
+ password == null -> throw PdfError("password_required", "PDF needs a password")
+ else -> throw PdfError("password_incorrect", "Wrong password")
+ }
+ }
+ val widths = ArrayList<Double>(renderer.pageCount)
+ val heights = ArrayList<Double>(renderer.pageCount)
+ try {
+ for (index in 0 until renderer.pageCount) {
+ renderer.openPage(index).use {
+ widths.add(it.width.toDouble())
+ heights.add(it.height.toDouble())
+ }
+ }
+ } catch (e: Exception) {
+ renderer.close()
+ throw e
+ }
+ val id = nextId++
+ documents[id] = renderer
+ return mapOf("id" to id, "widths" to widths, "heights" to heights)
+ }
+
+ private fun render(id: Int, page: Int, width: Int, height: Int): ByteArray {
+ val renderer = documents[id] ?: throw PdfError("invalid", "Document $id is closed")
+ val bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888)
+ try {
+ bitmap.eraseColor(Color.WHITE)
+ renderer.openPage(page - 1).use {
+ if (supportsPasswords) {
+ val params = RenderParams.Builder(PdfRenderer.Page.RENDER_MODE_FOR_DISPLAY)
+ .setRenderFlags(
+ RenderParams.FLAG_RENDER_TEXT_ANNOTATIONS or RenderParams.FLAG_RENDER_HIGHLIGHT_ANNOTATIONS,
+ )
+ .build()
+ it.render(bitmap, null, null, params)
+ } else {
+ it.render(bitmap, null, null, PdfRenderer.Page.RENDER_MODE_FOR_DISPLAY)
+ }
+ }
+ val output = ByteArrayOutputStream(width * height / 4)
+ bitmap.compress(Bitmap.CompressFormat.PNG, 100, output)
+ return output.toByteArray()
+ } finally {
+ bitmap.recycle()
+ }
+ }
+}
diff --git a/mobile/packages/ente_pdf_renderer/ios/Classes/EntePdfRendererPlugin.swift b/mobile/packages/ente_pdf_renderer/ios/Classes/EntePdfRendererPlugin.swift
new file mode 100644
index 0000000000..e61a38d463
--- /dev/null
+++ b/mobile/packages/ente_pdf_renderer/ios/Classes/EntePdfRendererPlugin.swift
@@ -0,0 +1,109 @@
+import Flutter
+import PDFKit
+import UIKit
+
+public class EntePdfRendererPlugin: NSObject, FlutterPlugin {
+ private struct PdfError: Error {
+ let code: String
+ let message: String
+ }
+
+ private var documents: [Int: PDFDocument] = [:]
+ private var nextId = 1
+ private let queue = DispatchQueue(label: "io.ente.pdf_renderer", qos: .userInitiated)
+
+ public static func register(with registrar: FlutterPluginRegistrar) {
+ let channel = FlutterMethodChannel(name: "io.ente/pdf_renderer", binaryMessenger: registrar.messenger())
+ registrar.addMethodCallDelegate(EntePdfRendererPlugin(), channel: channel)
+ }
+
+ public func handle(_ call: FlutterMethodCall, result: @escaping FlutterResult) {
+ let arguments = call.arguments as? [String: Any] ?? [:]
+ queue.async {
+ do {
+ let reply: Any?
+ switch call.method {
+ case "open":
+ guard let path = arguments["path"] as? String else {
+ throw PdfError(code: "invalid", message: "Missing path")
+ }
+ reply = try self.open(path: path, password: arguments["password"] as? String)
+ case "render":
+ guard let id = arguments["id"] as? Int, let page = arguments["page"] as? Int,
+ let width = arguments["width"] as? Int, let height = arguments["height"] as? Int else {
+ throw PdfError(code: "invalid", message: "Missing render arguments")
+ }
+ reply = try self.render(id: id, page: page, width: width, height: height)
+ case "close":
+ if let id = arguments["id"] as? Int {
+ self.documents.removeValue(forKey: id)
+ }
+ reply = nil
+ default:
+ DispatchQueue.main.async { result(FlutterMethodNotImplemented) }
+ return
+ }
+ DispatchQueue.main.async { result(reply) }
+ } catch let error as PdfError {
+ DispatchQueue.main.async {
+ result(FlutterError(code: error.code, message: error.message, details: nil))
+ }
+ } catch {
+ DispatchQueue.main.async { result(FlutterError(code: "invalid", message: "\(error)", details: nil)) }
+ }
+ }
+ }
+
+ private func rotatedSize(_ page: PDFPage) -> CGSize {
+ let bounds = page.bounds(for: .cropBox)
+ return page.rotation % 180 == 0 ? bounds.size : CGSize(width: bounds.height, height: bounds.width)
+ }
+
+ private func open(path: String, password: String?) throws -> [String: Any] {
+ guard let document = PDFDocument(url: URL(fileURLWithPath: path)) else {
+ throw PdfError(code: "invalid", message: "Not a readable PDF")
+ }
+ if document.isLocked {
+ guard let password else {
+ throw PdfError(code: "password_required", message: "PDF needs a password")
+ }
+ guard document.unlock(withPassword: password) else {
+ throw PdfError(code: "password_incorrect", message: "Wrong password")
+ }
+ }
+ var widths: [Double] = []
+ var heights: [Double] = []
+ for index in 0..<document.pageCount {
+ guard let page = document.page(at: index) else {
+ throw PdfError(code: "invalid", message: "Page \(index + 1) unreadable")
+ }
+ let size = rotatedSize(page)
+ widths.append(Double(size.width))
+ heights.append(Double(size.height))
+ }
+ let id = nextId
+ nextId += 1
+ documents[id] = document
+ return ["id": id, "widths": widths, "heights": heights]
+ }
+
+ private func render(id: Int, page: Int, width: Int, height: Int) throws -> FlutterStandardTypedData {
+ guard let document = documents[id], let pdfPage = document.page(at: page - 1) else {
+ throw PdfError(code: "invalid", message: "Document \(id) is closed")
+ }
+ let format = UIGraphicsImageRendererFormat()
+ format.scale = 1
+ format.opaque = true
+ let size = CGSize(width: width, height: height)
+ let pageSize = rotatedSize(pdfPage)
+ let data = UIGraphicsImageRenderer(size: size, format: format).pngData { context in
+ UIColor.white.setFill()
+ context.fill(CGRect(origin: .zero, size: size))
+ let graphics = context.cgContext
+ graphics.translateBy(x: 0, y: size.height)
+ graphics.scaleBy(x: size.width / pageSize.width, y: -size.height / pageSize.height)
+ pdfPage.draw(with: .cropBox, to: graphics)
+ }
+ return FlutterStandardTypedData(bytes: data)
+ }
+}
diff --git a/mobile/packages/ente_pdf_renderer/ios/ente_pdf_renderer.podspec b/mobile/packages/ente_pdf_renderer/ios/ente_pdf_renderer.podspec
new file mode 100644
index 0000000000..649ee98691
--- /dev/null
+++ b/mobile/packages/ente_pdf_renderer/ios/ente_pdf_renderer.podspec
@@ -0,0 +1,14 @@
+Pod::Spec.new do |s|
+ s.name = 'ente_pdf_renderer'
+ s.version = '0.0.1'
+ s.summary = 'PDFKit page rendering for Ente mobile apps.'
+ s.homepage = 'https://github.com/ente-io/ente'
+ s.license = { :type => 'AGPL-3.0-only' }
+ s.author = { 'Ente' => '[email protected]' }
+ s.source = { :path => '.' }
+ s.source_files = 'Classes/**/*'
+ s.dependency 'Flutter'
+ s.platform = :ios, '15.1'
+ s.pod_target_xcconfig = { 'DEFINES_MODULE' => 'YES' }
+ s.swift_version = '5.0'
+end
diff --git a/mobile/packages/ente_pdf_renderer/lib/ente_pdf_renderer.dart b/mobile/packages/ente_pdf_renderer/lib/ente_pdf_renderer.dart
new file mode 100644
index 0000000000..89ae5587b5
--- /dev/null
+++ b/mobile/packages/ente_pdf_renderer/lib/ente_pdf_renderer.dart
@@ -0,0 +1,83 @@
+import "package:flutter/services.dart";
+
+class PdfPasswordRequiredException implements Exception {
+ const PdfPasswordRequiredException();
+}
+
+class PdfPasswordIncorrectException implements Exception {
+ const PdfPasswordIncorrectException();
+}
+
+class PdfPasswordUnsupportedException implements Exception {
+ const PdfPasswordUnsupportedException();
+}
+
+class PdfException implements Exception {
+ const PdfException(this.message);
+
+ final String message;
+
+ @override
+ String toString() => "PdfException: $message";
+}
+
+class EntePdfDocument {
+ EntePdfDocument._(this._id, this.pageSizes);
+
+ final int _id;
+ final List<Size> pageSizes;
+
+ int get pageCount => pageSizes.length;
+
+ Future<Uint8List> render(
+ int page, {
+ required int width,
+ required int height,
+ }) async {
+ final bytes = await EntePdfRenderer._invoke<Uint8List>("render", {
+ "id": _id,
+ "page": page,
+ "width": width,
+ "height": height,
+ });
+ if (bytes == null) {
+ throw PdfException("Page $page rendered nothing");
+ }
+ return bytes;
+ }
+
+ Future<void> close() => EntePdfRenderer._invoke<void>("close", {"id": _id});
+}
+
+class EntePdfRenderer {
+ static const _channel = MethodChannel("io.ente/pdf_renderer");
+
+ static Future<EntePdfDocument> open(String path, {String? password}) async {
+ final reply = await _invoke<Map<Object?, Object?>>("open", {
+ "path": path,
+ "password": password,
+ });
+ final widths = (reply!["widths"]! as List).cast<double>();
+ final heights = (reply["heights"]! as List).cast<double>();
+ return EntePdfDocument._(reply["id"]! as int, [
+ for (var i = 0; i < widths.length; i++) Size(widths[i], heights[i]),
+ ]);
+ }
+
+ static Future<T?> _invoke<T>(String method, Map<String, Object?> args) async {
+ try {
+ return await _channel.invokeMethod<T>(method, args);
+ } on PlatformException catch (e) {
+ switch (e.code) {
+ case "password_required":
+ throw const PdfPasswordRequiredException();
+ case "password_incorrect":
+ throw const PdfPasswordIncorrectException();
+ case "password_unsupported":
+ throw const PdfPasswordUnsupportedException();
+ default:
+ throw PdfException(e.message ?? e.code);
+ }
+ }
+ }
+}
diff --git a/mobile/packages/ente_pdf_renderer/pubspec.yaml b/mobile/packages/ente_pdf_renderer/pubspec.yaml
new file mode 100644
index 0000000000..e3c3fc6958
--- /dev/null
+++ b/mobile/packages/ente_pdf_renderer/pubspec.yaml
@@ -0,0 +1,25 @@
+name: ente_pdf_renderer
+description: Renders PDF pages with the OS renderer (PdfRenderer on Android, PDFKit on iOS).
+
+resolution: workspace
+environment:
+ sdk: ">=3.10.0 <4.0.0"
+ flutter: ">=3.22.0"
+
+dependencies:
+ flutter:
+ sdk: flutter
+
+dev_dependencies:
+ flutter_lints: 6.0.0
+ flutter_test:
+ sdk: flutter
+
+flutter:
+ plugin:
+ platforms:
+ android:
+ package: io.ente.pdf_renderer
+ pluginClass: EntePdfRendererPlugin
+ ios:
+ pluginClass: EntePdfRendererPlugin
diff --git a/mobile/packages/ente_pdf_renderer/test/ente_pdf_renderer_test.dart b/mobile/packages/ente_pdf_renderer/test/ente_pdf_renderer_test.dart
new file mode 100644
index 0000000000..84fef5bda3
--- /dev/null
+++ b/mobile/packages/ente_pdf_renderer/test/ente_pdf_renderer_test.dart
@@ -0,0 +1,96 @@
+import "package:ente_pdf_renderer/ente_pdf_renderer.dart";
+import "package:flutter/services.dart";
+import "package:flutter_test/flutter_test.dart";
+
+void main() {
+ TestWidgetsFlutterBinding.ensureInitialized();
+ const channel = MethodChannel("io.ente/pdf_renderer");
+ final calls = <MethodCall>[];
+
+ void respond(Future<Object?> Function(MethodCall call) handler) {
+ TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger
+ .setMockMethodCallHandler(channel, (call) {
+ calls.add(call);
+ return handler(call);
+ });
+ }
+
+ void fail(String code, {String? message}) {
+ respond(
+ (call) async => throw PlatformException(code: code, message: message),
+ );
+ }
+
+ setUp(calls.clear);
+
+ tearDown(() {
+ TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger
+ .setMockMethodCallHandler(channel, null);
+ });
+
+ test("open maps page sizes and renders through the document id", () async {
+ respond((call) async {
+ switch (call.method) {
+ case "open":
+ return {
+ "id": 7,
+ "widths": [595.0, 842.0],
+ "heights": [842.0, 595.0],
+ };
+ case "render":
+ return Uint8List.fromList([1, 2, 3]);
+ default:
+ return null;
+ }
+ });
+
+ final document = await EntePdfRenderer.open("/tmp/a.pdf", password: "x");
+ expect(document.pageCount, 2);
+ expect(document.pageSizes[1], const Size(842, 595));
+ expect(calls.single.arguments, {"path": "/tmp/a.pdf", "password": "x"});
+
+ final bytes = await document.render(2, width: 100, height: 70);
+ expect(bytes, [1, 2, 3]);
+ expect(calls.last.arguments, {
+ "id": 7,
+ "page": 2,
+ "width": 100,
+ "height": 70,
+ });
+
+ await document.close();
+ expect(calls.last.method, "close");
+ });
+
+ test("platform error codes become typed exceptions", () async {
+ fail("password_required");
+ await expectLater(
+ EntePdfRenderer.open("/tmp/a.pdf"),
+ throwsA(isA<PdfPasswordRequiredException>()),
+ );
+
+ fail("password_incorrect");
+ await expectLater(
+ EntePdfRenderer.open("/tmp/a.pdf", password: "nope"),
+ throwsA(isA<PdfPasswordIncorrectException>()),
+ );
+
+ fail("password_unsupported");
+ await expectLater(
+ EntePdfRenderer.open("/tmp/a.pdf"),
+ throwsA(isA<PdfPasswordUnsupportedException>()),
+ );
+
+ fail("invalid", message: "Unable to load");
+ await expectLater(
+ EntePdfRenderer.open("/tmp/a.pdf"),
+ throwsA(
+ isA<PdfException>().having(
+ (e) => e.message,
+ "message",
+ "Unable to load",
+ ),
+ ),
+ );
+ });
+}
diff --git a/mobile/packages/strings/lib/l10n/arb/strings_en.arb b/mobile/packages/strings/lib/l10n/arb/strings_en.arb
index df72289d08..2cd037396a 100644
--- a/mobile/packages/strings/lib/l10n/arb/strings_en.arb
+++ b/mobile/packages/strings/lib/l10n/arb/strings_en.arb
@@ -2956,6 +2956,7 @@
"openAlbumInBrowser": "Open album in browser",
"openAlbumInBrowserTitle": "Please use the web app to add photos to this album",
"openFile": "Open file",
+ "openInAnotherApp": "Open in another app",
"openLink": "Open link",
"openSettings": "Open settings",
"openstreetmapContributors": "OpenStreetMap contributors",
@@ -3041,6 +3042,8 @@
}
}
},
+ "pdfNeedsPassword": "This PDF needs a password",
+ "pdfPasswordNotSupportedOnDevice": "This device cannot unlock password-protected PDFs. Open it in another app.",
"pending": "Pending",
"pendingSync": "Pending sync",
"pendingSyncs": "Warning",
@@ -4631,6 +4634,7 @@
"@unlock": {
"description": "Short action label used as the system authentication reason when unlocking the app"
},
+ "unlockPdf": "Unlock",
"unnamedCollection": "Unnamed collection",
"unnamedPeopleDoingSomethingTogether": "Doing it together",
"unnamedPeopleSpotlight": "A familiar face",
diff --git a/mobile/pubspec.yaml b/mobile/pubspec.yaml
index d39d1cc5ce..8ab779b895 100644
--- a/mobile/pubspec.yaml
+++ b/mobile/pubspec.yaml
@@ -34,6 +34,7 @@ workspace:
- packages/ente_crypto_api
- packages/ente_crypto_dart_adapter
- packages/ente_icons
+ - packages/ente_pdf_renderer
- packages/install_source
- packages/ente_pure_utils
- packages/ente_qr