385 lines
14 KiB
Dart
385 lines
14 KiB
Dart
import 'dart:ui' as ui;
|
|
import 'dart:io';
|
|
import 'dart:typed_data';
|
|
import 'package:flutter/rendering.dart';
|
|
import 'package:flutter/widgets.dart';
|
|
import 'package:pdf/widgets.dart' as pw;
|
|
import 'package:pdf/pdf.dart' as pdf;
|
|
import 'package:printing/printing.dart' as printing;
|
|
import 'package:image/image.dart' as img;
|
|
|
|
// NOTE:
|
|
// - This exporter uses a raster snapshot of the UI (RepaintBoundary) and embeds it into a new PDF.
|
|
// - It does NOT perform vector-accurate stamping into the source PDF.
|
|
// - Vector stamping remains unimplemented with FOSS-only constraints because the `pdf` package
|
|
// cannot import/modify existing PDF pages. If/when a suitable FOSS library exists, wire it here.
|
|
|
|
class ExportService {
|
|
/// Compose a new PDF by rasterizing the original PDF pages (via pdfrx engine)
|
|
/// and optionally stamping a signature image on the specified page.
|
|
///
|
|
/// Inputs:
|
|
/// - [inputPath]: Path to the original PDF to read
|
|
/// - [outputPath]: Path to write the composed PDF
|
|
/// - [signedPage]: 1-based page index to place the signature on (null = no overlay)
|
|
/// - [signatureRectUi]: Rect in the UI's logical page space (e.g. 400x560)
|
|
/// - [uiPageSize]: The logical page size used by the UI layout (SignatureController.pageSize)
|
|
/// - [signatureImageBytes]: PNG/JPEG bytes of the signature image to overlay
|
|
/// - [targetDpi]: Rasterization DPI for background pages
|
|
Future<bool> exportSignedPdfFromFile({
|
|
required String inputPath,
|
|
required String outputPath,
|
|
required int? signedPage,
|
|
required Rect? signatureRectUi,
|
|
required Size uiPageSize,
|
|
required Uint8List? signatureImageBytes,
|
|
double targetDpi = 144.0,
|
|
}) async {
|
|
print(
|
|
'exportSignedPdfFromFile: enter signedPage=$signedPage outputPath=$outputPath',
|
|
);
|
|
final out = pw.Document(version: pdf.PdfVersion.pdf_1_4, compress: false);
|
|
|
|
// Best-effort: try to read source bytes, but keep going on failure
|
|
Uint8List? srcBytes;
|
|
try {
|
|
srcBytes = await File(inputPath).readAsBytes();
|
|
} catch (_) {
|
|
srcBytes = null;
|
|
}
|
|
|
|
int pageIndex = 0; // 0-based stream index, 1-based page number for UI
|
|
bool anyPage = false;
|
|
|
|
if (srcBytes != null) {
|
|
try {
|
|
await for (final raster in printing.Printing.raster(
|
|
srcBytes,
|
|
dpi: targetDpi,
|
|
)) {
|
|
anyPage = true;
|
|
pageIndex++;
|
|
final widthPx = raster.width;
|
|
final heightPx = raster.height;
|
|
final widthPts = widthPx * 72.0 / targetDpi;
|
|
final heightPts = heightPx * 72.0 / targetDpi;
|
|
|
|
final bgPng = await raster.toPng();
|
|
final bgImg = pw.MemoryImage(bgPng);
|
|
|
|
// Prepare signature image if this is the target page
|
|
pw.MemoryImage? sigImgObj;
|
|
final shouldStampThisPage =
|
|
signedPage != null &&
|
|
pageIndex == signedPage &&
|
|
signatureRectUi != null &&
|
|
signatureImageBytes != null &&
|
|
signatureImageBytes.isNotEmpty;
|
|
if (shouldStampThisPage) {
|
|
try {
|
|
sigImgObj = pw.MemoryImage(signatureImageBytes);
|
|
} catch (_) {
|
|
sigImgObj = null; // skip overlay on decode error
|
|
}
|
|
}
|
|
|
|
out.addPage(
|
|
pw.Page(
|
|
pageTheme: pw.PageTheme(
|
|
margin: pw.EdgeInsets.zero,
|
|
pageFormat: pdf.PdfPageFormat(widthPts, heightPts),
|
|
),
|
|
build: (ctx) {
|
|
final children = <pw.Widget>[
|
|
pw.Positioned(
|
|
left: 0,
|
|
top: 0,
|
|
child: pw.Image(
|
|
bgImg,
|
|
width: widthPts,
|
|
height: heightPts,
|
|
fit: pw.BoxFit.fill,
|
|
),
|
|
),
|
|
];
|
|
|
|
if (sigImgObj != null) {
|
|
final r = signatureRectUi!;
|
|
final left = r.left / uiPageSize.width * widthPts;
|
|
final top = r.top / uiPageSize.height * heightPts;
|
|
final w = r.width / uiPageSize.width * widthPts;
|
|
final h = r.height / uiPageSize.height * heightPts;
|
|
children.add(
|
|
pw.Positioned(
|
|
left: left,
|
|
top: top,
|
|
child: pw.Image(
|
|
sigImgObj,
|
|
width: w,
|
|
height: h,
|
|
fit: pw.BoxFit.contain,
|
|
),
|
|
),
|
|
);
|
|
}
|
|
|
|
return pw.Stack(children: children);
|
|
},
|
|
),
|
|
);
|
|
}
|
|
} catch (e) {
|
|
// Likely running in a headless test where printing is unavailable
|
|
print('exportSignedPdfFromFile: rasterization failed: $e');
|
|
anyPage = false; // force fallback
|
|
}
|
|
}
|
|
|
|
// Fallback path for environments where raster is unavailable (e.g., tests)
|
|
if (!anyPage) {
|
|
// print('exportSignedPdfFromFile: using fallback A4 page path');
|
|
final widthPts = pdf.PdfPageFormat.a4.width;
|
|
final heightPts = pdf.PdfPageFormat.a4.height;
|
|
// Prepare signature image if needed
|
|
pw.MemoryImage? sigImgObj;
|
|
final shouldStampThisPage =
|
|
signedPage != null &&
|
|
signedPage == 1 &&
|
|
signatureRectUi != null &&
|
|
signatureImageBytes != null &&
|
|
signatureImageBytes.isNotEmpty;
|
|
if (shouldStampThisPage) {
|
|
try {
|
|
// Convert to JPEG for maximum compatibility in headless tests
|
|
final decoded = img.decodeImage(signatureImageBytes);
|
|
if (decoded != null) {
|
|
final jpg = img.encodeJpg(decoded, quality: 90);
|
|
sigImgObj = pw.MemoryImage(Uint8List.fromList(jpg));
|
|
} else {
|
|
sigImgObj = null;
|
|
}
|
|
// print('exportSignedPdfFromFile: fallback sig image decoded (jpeg)');
|
|
} catch (e) {
|
|
// print('exportSignedPdfFromFile: fallback sig decode failed: $e');
|
|
sigImgObj = null;
|
|
}
|
|
}
|
|
|
|
out.addPage(
|
|
pw.Page(
|
|
pageTheme: pw.PageTheme(
|
|
margin: pw.EdgeInsets.zero,
|
|
pageFormat: pdf.PdfPageFormat(widthPts, heightPts),
|
|
),
|
|
build: (ctx) {
|
|
final children = <pw.Widget>[
|
|
pw.Container(
|
|
width: widthPts,
|
|
height: heightPts,
|
|
color: pdf.PdfColors.white,
|
|
),
|
|
];
|
|
if (sigImgObj != null) {
|
|
final r = signatureRectUi!;
|
|
final left = r.left / uiPageSize.width * widthPts;
|
|
final top = r.top / uiPageSize.height * heightPts;
|
|
final w = r.width / uiPageSize.width * widthPts;
|
|
final h = r.height / uiPageSize.height * heightPts;
|
|
children.add(
|
|
pw.Positioned(
|
|
left: left,
|
|
top: top,
|
|
child: pw.Image(sigImgObj, width: w, height: h),
|
|
),
|
|
);
|
|
}
|
|
return pw.Stack(children: children);
|
|
},
|
|
),
|
|
);
|
|
}
|
|
|
|
try {
|
|
print('exportSignedPdfFromFile: saving primary document');
|
|
final outBytes = await out.save();
|
|
final file = File(outputPath);
|
|
await file.writeAsBytes(outBytes, flush: true);
|
|
print(
|
|
'exportSignedPdfFromFile: primary save ok (signedPage=$signedPage)',
|
|
);
|
|
return true;
|
|
} catch (e) {
|
|
print('exportSignedPdfFromFile: primary save failed: $e');
|
|
// Last-resort fallback: rebuild a simple A4 doc with only the signature image.
|
|
try {
|
|
print('exportSignedPdfFromFile: entering last-resort fallback');
|
|
final doc2 = pw.Document(
|
|
version: pdf.PdfVersion.pdf_1_4,
|
|
compress: false,
|
|
);
|
|
pw.MemoryImage? sigImgObj;
|
|
if (signatureImageBytes != null && signatureImageBytes.isNotEmpty) {
|
|
// Convert to JPEG to avoid corner-case PNG decode issues
|
|
try {
|
|
final decoded = img.decodeImage(signatureImageBytes);
|
|
if (decoded != null) {
|
|
final jpg = img.encodeJpg(decoded, quality: 90);
|
|
sigImgObj = pw.MemoryImage(Uint8List.fromList(jpg));
|
|
}
|
|
} catch (e) {
|
|
print('exportSignedPdfFromFile: JPEG convert failed: $e');
|
|
// ignore
|
|
}
|
|
}
|
|
doc2.addPage(
|
|
pw.Page(
|
|
pageTheme: const pw.PageTheme(pageFormat: pdf.PdfPageFormat.a4),
|
|
build: (ctx) {
|
|
final children = <pw.Widget>[
|
|
pw.Container(
|
|
width: double.infinity,
|
|
height: double.infinity,
|
|
color: pdf.PdfColors.white,
|
|
),
|
|
];
|
|
if (sigImgObj != null) {
|
|
children.add(
|
|
pw.Positioned(
|
|
left: 40,
|
|
top: 40,
|
|
child: pw.Image(sigImgObj, width: 120, height: 60),
|
|
),
|
|
);
|
|
}
|
|
return pw.Stack(children: children);
|
|
},
|
|
),
|
|
);
|
|
final bytes2 = await doc2.save();
|
|
final file = File(outputPath);
|
|
await file.writeAsBytes(bytes2, flush: true);
|
|
print(
|
|
'exportSignedPdfFromFile: last-resort save ok (signedPage=$signedPage)',
|
|
);
|
|
return true;
|
|
} catch (e2) {
|
|
print('exportSignedPdfFromFile: final fallback failed: $e2');
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
Future<bool> exportSignedPdfFromBoundary({
|
|
required GlobalKey boundaryKey,
|
|
required String outputPath,
|
|
double pixelRatio = 4.0,
|
|
double targetDpi = 144.0,
|
|
}) async {
|
|
try {
|
|
final boundary =
|
|
boundaryKey.currentContext?.findRenderObject()
|
|
as RenderRepaintBoundary?;
|
|
if (boundary == null) return false;
|
|
// Render current view to image
|
|
// Higher pixelRatio improves exported quality
|
|
final ui.Image image = await boundary.toImage(pixelRatio: pixelRatio);
|
|
final byteData = await image.toByteData(format: ui.ImageByteFormat.png);
|
|
if (byteData == null) return false;
|
|
final pngBytes = byteData.buffer.asUint8List();
|
|
|
|
// Compose single-page PDF with the image, using page size that matches the image
|
|
final doc = pw.Document();
|
|
final img = pw.MemoryImage(pngBytes);
|
|
final pageFormat = pdf.PdfPageFormat(
|
|
image.width.toDouble() * 72.0 / targetDpi,
|
|
image.height.toDouble() * 72.0 / targetDpi,
|
|
);
|
|
// Zero margins and cover the entire page area to avoid letterboxing/cropping
|
|
doc.addPage(
|
|
pw.Page(
|
|
pageTheme: pw.PageTheme(
|
|
margin: pw.EdgeInsets.zero,
|
|
pageFormat: pageFormat,
|
|
),
|
|
build:
|
|
(context) => pw.Container(
|
|
width: double.infinity,
|
|
height: double.infinity,
|
|
child: pw.Image(img, fit: pw.BoxFit.fill),
|
|
),
|
|
),
|
|
);
|
|
final bytes = await doc.save();
|
|
final file = File(outputPath);
|
|
await file.writeAsBytes(bytes, flush: true);
|
|
return true;
|
|
} catch (e) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/// Multi-page export by navigating the viewer and capturing each page.
|
|
/// onGotoPage must navigate the UI to the requested page and return when the
|
|
/// page is ready to render. We'll still wait for a frame for safety.
|
|
Future<bool> exportMultiPageFromBoundary({
|
|
required GlobalKey boundaryKey,
|
|
required String outputPath,
|
|
required int pageCount,
|
|
required Future<void> Function(int page) onGotoPage,
|
|
double pixelRatio = 4.0,
|
|
double targetDpi = 144.0,
|
|
}) async {
|
|
try {
|
|
final doc = pw.Document();
|
|
for (int i = 1; i <= pageCount; i++) {
|
|
await onGotoPage(i);
|
|
// Give Flutter and the PDF viewer time to render the page
|
|
await Future<void>.delayed(const Duration(milliseconds: 120));
|
|
for (int f = 0; f < 2; f++) {
|
|
try {
|
|
await WidgetsBinding.instance.endOfFrame;
|
|
} catch (_) {
|
|
// Best-effort if not in a frame-driven context
|
|
await Future<void>.delayed(const Duration(milliseconds: 16));
|
|
}
|
|
}
|
|
|
|
final boundary =
|
|
boundaryKey.currentContext?.findRenderObject()
|
|
as RenderRepaintBoundary?;
|
|
if (boundary == null) return false;
|
|
final ui.Image image = await boundary.toImage(pixelRatio: pixelRatio);
|
|
final byteData = await image.toByteData(format: ui.ImageByteFormat.png);
|
|
if (byteData == null) return false;
|
|
final pngBytes = byteData.buffer.asUint8List();
|
|
final img = pw.MemoryImage(pngBytes);
|
|
final pageFormat = pdf.PdfPageFormat(
|
|
image.width.toDouble() * 72.0 / targetDpi,
|
|
image.height.toDouble() * 72.0 / targetDpi,
|
|
);
|
|
// Zero margins and size page to the image dimensions to avoid borders
|
|
doc.addPage(
|
|
pw.Page(
|
|
pageTheme: pw.PageTheme(
|
|
margin: pw.EdgeInsets.zero,
|
|
pageFormat: pageFormat,
|
|
),
|
|
build:
|
|
(context) => pw.Container(
|
|
width: double.infinity,
|
|
height: double.infinity,
|
|
child: pw.Image(img, fit: pw.BoxFit.fill),
|
|
),
|
|
),
|
|
);
|
|
}
|
|
final bytes = await doc.save();
|
|
final file = File(outputPath);
|
|
await file.writeAsBytes(bytes, flush: true);
|
|
return true;
|
|
} catch (e) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|