Send sheet: opens on what recipients will see (the encoded photo decoded on this device) instead of the original. "Try another version" encodes the whole photo again with a near-invisible zoom/shift; the generative decoder reconstructs each version differently, and on Kodak the best of three raised CLIP agreement from 0.828 to 0.853. The user picks the version to send; packet count and airtime follow the selection. Version 1 is byte-identical to the previous encode, so the wire format is unchanged. The sender's bubble shows the chosen version and carries the AI-reconstructed label. Repeater echoes: the raw RX log handler now decrypts GRP_DATA as well as GRP_TXT and counts repeaters re-flooding each chunk of our own images. The bubble shows the repeat count like channel text, and Packet info lists each packet. About 15 s after sending, chunks no repeater echoed are resent once, but only when another chunk of the same image was echoed, so senders with no repeater in earshot do not double their airtime. Outgoing entries now record their payload size.
689 lines
23 KiB
Dart
689 lines
23 KiB
Dart
/// In-bubble renderer for AEIC images received over the mesh.
|
|
///
|
|
/// Mirrors `lib/widgets/gif_message.dart`: a fixed-size box (so the reversed
|
|
/// `ListView` never jumps as chunks land), one widget per message, all state
|
|
/// pulled from [ReceivedImageStore].
|
|
///
|
|
/// ## RISK R6 — permanent synthesized-content label
|
|
///
|
|
/// A 156-byte AEIC bitstream decoded by a one-step diffusion model is not a
|
|
/// photograph. On the measurement corpus this decoder turned a fox into a
|
|
/// sharp, natural, artefact-free sheep. Every decoded image therefore carries
|
|
/// TWO provenance elements that no caller can influence:
|
|
///
|
|
/// * [_SyntheticBanner] — a band burnt into the bottom of the image itself,
|
|
/// inside the `ClipRRect`, inside the `Stack`. It is
|
|
/// part of the pixels the user sees and part of any
|
|
/// screenshot that contains the image at all.
|
|
/// * [_SyntheticCaption] — a line of text immediately under the image.
|
|
///
|
|
/// Both are private to this file, are not parameterised, and are reused
|
|
/// verbatim by the full-screen viewer this widget opens on tap, so there is no
|
|
/// route in the app that can show the pixels without them. They are absent
|
|
/// only when [ReceivedImageEntry.synthesized] is false: the sender's own image
|
|
/// on a device that could not decode, where the PNG is their stretched
|
|
/// original and the label would be a falsehood. The sender's own image is
|
|
/// otherwise the decoded version they picked, so it is labelled like any
|
|
/// other. That is read from the store's sidecar, never from a constructor
|
|
/// argument.
|
|
///
|
|
/// The widget deliberately exposes no share/save action: an exported raster
|
|
/// would have to have the caption composited into it first, and that belongs
|
|
/// with whoever implements export, not here.
|
|
library;
|
|
|
|
import 'package:flutter/material.dart';
|
|
import 'package:flutter/services.dart';
|
|
import 'package:provider/provider.dart';
|
|
|
|
import '../l10n/app_localizations.dart';
|
|
import '../l10n/l10n.dart';
|
|
import '../services/received_image_store.dart';
|
|
import 'image_send_codec_binding.dart' show ImageCodecAvailability;
|
|
|
|
/// User-visible strings for the NON-decoded states.
|
|
///
|
|
/// Built from `AppLocalizations` by [ReceivedImageStrings.of]; the widget does
|
|
/// that itself when no [ReceivedImageMessage.strings] override is passed.
|
|
/// Deliberately contains no field for the R6 badge or caption: those must not
|
|
/// be overridable, shortenable or blankable.
|
|
@immutable
|
|
class ReceivedImageStrings {
|
|
final String Function(int received, int total) incoming;
|
|
final String queued;
|
|
final String tapToDecode;
|
|
|
|
/// Headline of the awaiting-action placeholder: how big the bitstream is and
|
|
/// how many packets carried it, e.g. "156 bytes · 2 packets".
|
|
final String Function(int bytes, int packets) awaiting;
|
|
|
|
/// The affordance on the awaiting-action placeholder.
|
|
final String tapToProcess;
|
|
final String decoding;
|
|
final String Function(int received, int total) incomplete;
|
|
final String corrupt;
|
|
final String decoderMissing;
|
|
final String evicted;
|
|
final String retry;
|
|
final String decodeAgain;
|
|
final String openSettings;
|
|
|
|
const ReceivedImageStrings({
|
|
required this.incoming,
|
|
required this.queued,
|
|
required this.tapToDecode,
|
|
required this.awaiting,
|
|
required this.tapToProcess,
|
|
required this.decoding,
|
|
required this.incomplete,
|
|
required this.corrupt,
|
|
required this.decoderMissing,
|
|
required this.evicted,
|
|
required this.retry,
|
|
required this.decodeAgain,
|
|
required this.openSettings,
|
|
});
|
|
|
|
/// The app's `receivedImage_*` strings for [l10n]'s locale.
|
|
factory ReceivedImageStrings.of(AppLocalizations l10n) =>
|
|
ReceivedImageStrings(
|
|
incoming: l10n.receivedImage_incoming,
|
|
queued: l10n.receivedImage_queued,
|
|
tapToDecode: l10n.receivedImage_tapToDecode,
|
|
awaiting: l10n.receivedImage_awaiting,
|
|
tapToProcess: l10n.receivedImage_tapToProcess,
|
|
decoding: l10n.receivedImage_decoding,
|
|
incomplete: l10n.receivedImage_incomplete,
|
|
corrupt: l10n.receivedImage_corrupt,
|
|
decoderMissing: l10n.receivedImage_decoderMissing,
|
|
evicted: l10n.receivedImage_evicted,
|
|
retry: l10n.receivedImage_retry,
|
|
decodeAgain: l10n.receivedImage_decodeAgain,
|
|
openSettings: l10n.receivedImage_openSettings,
|
|
);
|
|
}
|
|
|
|
/// The R6 label texts, localised but never injectable and never empty.
|
|
///
|
|
/// Resolved inside the private R6 widgets from the widget tree, so no caller
|
|
/// can pass a replacement. If the tree has no `AppLocalizations`, or a
|
|
/// translation is blank, the English text is used instead: a missing
|
|
/// translation must never be able to remove the label.
|
|
AppLocalizations _r6Strings(BuildContext context) {
|
|
final l10n = Localizations.of<AppLocalizations>(context, AppLocalizations);
|
|
if (l10n != null &&
|
|
l10n.receivedImage_syntheticBadge.trim().isNotEmpty &&
|
|
l10n.receivedImage_shareCaption(0).trim().isNotEmpty) {
|
|
return l10n;
|
|
}
|
|
return lookupAppLocalizations(const Locale('en'));
|
|
}
|
|
|
|
/// Text of the R6 badge burnt into the image.
|
|
String _syntheticBadge(BuildContext context) =>
|
|
_r6Strings(context).receivedImage_syntheticBadge;
|
|
|
|
/// The caption is built from the ACTUAL bitstream size, never a nominal one:
|
|
/// quoting a fixed "~156 bytes" under an image that took 209 is its own small
|
|
/// dishonesty, in a label whose whole job is honesty. Same sentence as the
|
|
/// share text in the channel screen, so the label reads identically wherever
|
|
/// the image goes.
|
|
String _syntheticCaptionFor(BuildContext context, int bytes) =>
|
|
_r6Strings(context).receivedImage_shareCaption(bytes);
|
|
|
|
class ReceivedImageMessage extends StatefulWidget {
|
|
/// 14 hex chars, as parsed out of the message text by
|
|
/// [ReceivedImageRef.parse].
|
|
final String streamId;
|
|
|
|
/// True for the local user's own message. Not an R6 escape hatch: the label is
|
|
/// driven by [ReceivedImageEntry.synthesized], which is derived in the store.
|
|
final bool isOutgoing;
|
|
|
|
/// Colour for the explanatory text inside a chat bubble.
|
|
final Color fallbackTextColor;
|
|
|
|
final double maxSize;
|
|
|
|
/// Test/preview override. Normally resolved from the widget tree.
|
|
final ReceivedImageStore? store;
|
|
|
|
final ReceivedImageStrings? strings;
|
|
|
|
/// Route to the image-messages settings page (offered only when the decoder
|
|
/// is missing because no weights are downloaded).
|
|
final VoidCallback? onOpenCodecSettings;
|
|
|
|
const ReceivedImageMessage({
|
|
super.key,
|
|
required this.streamId,
|
|
required this.isOutgoing,
|
|
required this.fallbackTextColor,
|
|
this.maxSize = 200,
|
|
this.store,
|
|
this.strings,
|
|
this.onOpenCodecSettings,
|
|
});
|
|
|
|
@override
|
|
State<ReceivedImageMessage> createState() => _ReceivedImageMessageState();
|
|
}
|
|
|
|
class _ReceivedImageMessageState extends State<ReceivedImageMessage> {
|
|
ReceivedImageStore? _store;
|
|
|
|
/// Which stream we have already asked the store to page in. Keyed by id, not
|
|
/// a bare bool: a `ListView` recycles this State object across messages, and
|
|
/// a bool left over from the previous stream meant the new one's pixels were
|
|
/// never requested and the bubble sat on a spinner forever.
|
|
String? _pngRequestedFor;
|
|
|
|
ReceivedImageStore? _resolveStore() {
|
|
final injected = widget.store;
|
|
if (injected != null) return injected;
|
|
try {
|
|
return Provider.of<ReceivedImageStore>(context, listen: false);
|
|
} on ProviderNotFoundException {
|
|
// The receive service is not registered (e.g. a screen test); render the
|
|
// "no decoder" state rather than crashing the whole message list.
|
|
return null;
|
|
}
|
|
}
|
|
|
|
@override
|
|
void didChangeDependencies() {
|
|
super.didChangeDependencies();
|
|
_store = _resolveStore();
|
|
_maybeLoadPng();
|
|
}
|
|
|
|
@override
|
|
void didUpdateWidget(covariant ReceivedImageMessage oldWidget) {
|
|
super.didUpdateWidget(oldWidget);
|
|
if (oldWidget.streamId != widget.streamId) {
|
|
_pngRequestedFor = null;
|
|
_store = _resolveStore();
|
|
_maybeLoadPng();
|
|
}
|
|
}
|
|
|
|
void _maybeLoadPng() {
|
|
final store = _store;
|
|
if (store == null) return;
|
|
if (_pngRequestedFor == widget.streamId) return;
|
|
final entry = store.entryFor(widget.streamId);
|
|
if (entry == null) return;
|
|
if (entry.state != ReceivedImageState.decoded) return;
|
|
if (entry.pngBytes != null) return;
|
|
_pngRequestedFor = widget.streamId;
|
|
store.ensurePng(widget.streamId);
|
|
}
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
final store = _store;
|
|
if (store == null) {
|
|
return _box(context, _unavailableBody(context, null));
|
|
}
|
|
return ValueListenableBuilder<ReceivedImageEntry?>(
|
|
valueListenable: store.listenableFor(widget.streamId),
|
|
builder: (context, _, _) {
|
|
final entry = store.entryFor(widget.streamId);
|
|
_maybeLoadPng();
|
|
if (entry == null) {
|
|
return _box(context, _unavailableBody(context, null));
|
|
}
|
|
return _buildForEntry(context, store, entry);
|
|
},
|
|
);
|
|
}
|
|
|
|
ReceivedImageStrings get _s =>
|
|
widget.strings ?? ReceivedImageStrings.of(context.l10n);
|
|
|
|
Widget _buildForEntry(
|
|
BuildContext context,
|
|
ReceivedImageStore store,
|
|
ReceivedImageEntry entry,
|
|
) {
|
|
switch (entry.state) {
|
|
case ReceivedImageState.decoded:
|
|
final png = entry.pngBytes;
|
|
if (png == null) {
|
|
return _box(
|
|
context,
|
|
_progressBody(context, progress: null, label: _s.decoding),
|
|
);
|
|
}
|
|
return _decodedBody(context, entry, png);
|
|
|
|
case ReceivedImageState.receiving:
|
|
final total = entry.totalChunks <= 0 ? 1 : entry.totalChunks;
|
|
return _box(
|
|
context,
|
|
_progressBody(
|
|
context,
|
|
progress: (entry.receivedChunks / total).clamp(0.0, 1.0),
|
|
label: _s.incoming(entry.receivedChunks, total),
|
|
),
|
|
);
|
|
|
|
// "Bitstream complete, not decoded". Two shades of it, distinguished by
|
|
// queue membership rather than by a fourth enum value:
|
|
// needsManualDecode -> parked, waiting for a tap (the setting is off,
|
|
// or the burst cap trimmed it)
|
|
// !needsManualDecode -> already in the store's decode queue
|
|
// Both are tappable. The second one deliberately so: a sidecar restored
|
|
// by load() is never re-enqueued, so without a tap target a restored
|
|
// "Waiting to decode" card would be dead forever.
|
|
case ReceivedImageState.reassembled:
|
|
return _box(
|
|
context,
|
|
_iconBody(
|
|
context,
|
|
icon: entry.needsManualDecode
|
|
? Icons.image_outlined
|
|
: Icons.hourglass_empty,
|
|
label: entry.needsManualDecode
|
|
? _s.awaiting(entry.bitstreamByteCount, entry.totalChunks)
|
|
: _s.queued,
|
|
action: entry.needsManualDecode
|
|
? _ActionSpec(
|
|
_s.tapToProcess,
|
|
() => _onProcessTap(store, entry),
|
|
)
|
|
: null,
|
|
),
|
|
onTap: () => _onProcessTap(store, entry),
|
|
);
|
|
|
|
case ReceivedImageState.decoding:
|
|
return _box(
|
|
context,
|
|
_progressBody(context, progress: null, label: _s.decoding),
|
|
);
|
|
|
|
case ReceivedImageState.failedIncomplete:
|
|
return _box(
|
|
context,
|
|
_iconBody(
|
|
context,
|
|
icon: Icons.broken_image_outlined,
|
|
label: _s.incomplete(entry.receivedChunks, entry.totalChunks),
|
|
isError: true,
|
|
),
|
|
);
|
|
|
|
case ReceivedImageState.failedCorrupt:
|
|
return _box(
|
|
context,
|
|
_iconBody(
|
|
context,
|
|
icon: Icons.error_outline,
|
|
label: _s.corrupt,
|
|
isError: true,
|
|
action: entry.canRetryDecode
|
|
? _ActionSpec(
|
|
_s.retry,
|
|
() => store.requestDecode(entry.streamId),
|
|
)
|
|
: null,
|
|
),
|
|
);
|
|
|
|
case ReceivedImageState.decoderUnavailable:
|
|
return _box(context, _unavailableBody(context, entry));
|
|
|
|
case ReceivedImageState.evicted:
|
|
return _box(
|
|
context,
|
|
_iconBody(
|
|
context,
|
|
icon: Icons.delete_outline,
|
|
label: _s.evicted,
|
|
action: entry.canRetryDecode
|
|
? _ActionSpec(
|
|
_s.decodeAgain,
|
|
() => store.requestDecode(entry.streamId),
|
|
)
|
|
: null,
|
|
),
|
|
);
|
|
}
|
|
}
|
|
|
|
/// Availability of the store's decoder seam.
|
|
///
|
|
/// Read through the store's public `decoder` field rather than importing
|
|
/// `ImageCodecService`: the bubble only needs to know whether a tap would
|
|
/// reach a working codec.
|
|
ImageCodecAvailability _availability(ReceivedImageStore store) =>
|
|
store.decoder?.availability ?? ImageCodecAvailability.unavailable;
|
|
|
|
/// The one tap handler for the awaiting-action card.
|
|
///
|
|
/// With no model installed, going through [ReceivedImageStore.requestDecode]
|
|
/// would cost the user two taps: the entry would flip to
|
|
/// `decoderUnavailable`, and only *then* would the card offer a "Set up"
|
|
/// button. So when the codec is not ready and the host screen gave us a route
|
|
/// to the image-messages setting, go straight there.
|
|
void _onProcessTap(ReceivedImageStore store, ReceivedImageEntry entry) {
|
|
final openSettings = widget.onOpenCodecSettings;
|
|
if (_availability(store) != ImageCodecAvailability.ready &&
|
|
openSettings != null) {
|
|
openSettings();
|
|
return;
|
|
}
|
|
store.requestDecode(entry.streamId);
|
|
}
|
|
|
|
// ---- bodies --------------------------------------------------------------
|
|
|
|
/// 4:3 placeholder box, same discipline as `GifMessage`, so a bubble does not
|
|
/// resize as an image progresses.
|
|
Widget _box(BuildContext context, Widget child, {VoidCallback? onTap}) {
|
|
final theme = Theme.of(context);
|
|
final box = Container(
|
|
width: widget.maxSize,
|
|
height: widget.maxSize * 0.75,
|
|
padding: const EdgeInsets.all(8),
|
|
decoration: BoxDecoration(
|
|
color: theme.colorScheme.surfaceContainerHighest.withValues(alpha: 0.4),
|
|
borderRadius: BorderRadius.circular(8),
|
|
),
|
|
child: Center(child: child),
|
|
);
|
|
if (onTap == null) return box;
|
|
return GestureDetector(onTap: onTap, child: box);
|
|
}
|
|
|
|
Widget _progressBody(
|
|
BuildContext context, {
|
|
required double? progress,
|
|
required String label,
|
|
}) {
|
|
return Column(
|
|
mainAxisAlignment: MainAxisAlignment.center,
|
|
mainAxisSize: MainAxisSize.min,
|
|
children: [
|
|
SizedBox(
|
|
width: 22,
|
|
height: 22,
|
|
child: CircularProgressIndicator(strokeWidth: 2, value: progress),
|
|
),
|
|
const SizedBox(height: 8),
|
|
_label(context, label),
|
|
],
|
|
);
|
|
}
|
|
|
|
Widget _iconBody(
|
|
BuildContext context, {
|
|
required IconData icon,
|
|
required String label,
|
|
bool isError = false,
|
|
_ActionSpec? action,
|
|
}) {
|
|
final color = isError
|
|
? Theme.of(context).colorScheme.error
|
|
: widget.fallbackTextColor;
|
|
return Column(
|
|
mainAxisAlignment: MainAxisAlignment.center,
|
|
mainAxisSize: MainAxisSize.min,
|
|
children: [
|
|
Icon(icon, size: 22, color: color),
|
|
const SizedBox(height: 6),
|
|
_label(context, label, color: color),
|
|
if (action != null)
|
|
TextButton(
|
|
onPressed: action.onPressed,
|
|
style: TextButton.styleFrom(
|
|
padding: const EdgeInsets.symmetric(horizontal: 8),
|
|
minimumSize: const Size(0, 28),
|
|
tapTargetSize: MaterialTapTargetSize.shrinkWrap,
|
|
),
|
|
child: Text(action.label, style: const TextStyle(fontSize: 12)),
|
|
),
|
|
],
|
|
);
|
|
}
|
|
|
|
Widget _unavailableBody(BuildContext context, ReceivedImageEntry? entry) {
|
|
final canSetUp = widget.onOpenCodecSettings != null;
|
|
return _iconBody(
|
|
context,
|
|
icon: Icons.visibility_off_outlined,
|
|
label: _s.decoderMissing,
|
|
action: canSetUp
|
|
? _ActionSpec(_s.openSettings, widget.onOpenCodecSettings!)
|
|
: (entry != null && entry.canRetryDecode && _store != null
|
|
? _ActionSpec(
|
|
_s.retry,
|
|
() => _store!.requestDecode(entry.streamId),
|
|
)
|
|
: null),
|
|
);
|
|
}
|
|
|
|
Widget _label(BuildContext context, String text, {Color? color}) {
|
|
return Text(
|
|
text,
|
|
textAlign: TextAlign.center,
|
|
maxLines: 3,
|
|
overflow: TextOverflow.ellipsis,
|
|
style: TextStyle(fontSize: 12, color: color ?? widget.fallbackTextColor),
|
|
);
|
|
}
|
|
|
|
// ---- decoded (R6) --------------------------------------------------------
|
|
|
|
Widget _decodedBody(
|
|
BuildContext context,
|
|
ReceivedImageEntry entry,
|
|
Uint8List png,
|
|
) {
|
|
final size = widget.maxSize;
|
|
return GestureDetector(
|
|
onTap: () => _openViewer(context, entry, png),
|
|
child: Column(
|
|
mainAxisSize: MainAxisSize.min,
|
|
crossAxisAlignment: CrossAxisAlignment.start,
|
|
children: [
|
|
ClipRRect(
|
|
borderRadius: BorderRadius.circular(8),
|
|
child: SizedBox(
|
|
width: size,
|
|
// The codec always produces a 512x512 square because the sender
|
|
// stretched the whole frame into it. entry.displayAspectRatio is
|
|
// the shape it started as, so undo the stretch here rather than
|
|
// showing a widened photo. Null means square or unknown.
|
|
height: entry.displayAspectRatio == null
|
|
? size
|
|
: size / entry.displayAspectRatio!,
|
|
child: Stack(
|
|
children: [
|
|
Positioned.fill(
|
|
// fill, not contain: the pixels ARE the stretched square,
|
|
// so mapping them onto the original aspect box is exactly
|
|
// the inverse of what the sender did.
|
|
child: Image.memory(png, fit: BoxFit.fill),
|
|
),
|
|
if (entry.synthesized)
|
|
const Positioned(
|
|
left: 0,
|
|
right: 0,
|
|
bottom: 0,
|
|
child: _SyntheticBanner(),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
),
|
|
if (entry.synthesized)
|
|
SizedBox(
|
|
width: size,
|
|
child: _SyntheticCaption(bytes: entry.bitstreamByteCount),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
}
|
|
|
|
void _openViewer(
|
|
BuildContext context,
|
|
ReceivedImageEntry entry,
|
|
Uint8List png,
|
|
) {
|
|
Navigator.of(context).push(
|
|
MaterialPageRoute<void>(
|
|
builder: (_) => _ReceivedImageViewer(
|
|
png: png,
|
|
synthesized: entry.synthesized,
|
|
bytes: entry.bitstreamByteCount,
|
|
aspectRatio: entry.displayAspectRatio,
|
|
),
|
|
),
|
|
);
|
|
}
|
|
}
|
|
|
|
class _ActionSpec {
|
|
final String label;
|
|
final VoidCallback onPressed;
|
|
|
|
const _ActionSpec(this.label, this.onPressed);
|
|
}
|
|
|
|
/// R6, part 1: a band composited over the bottom of the image.
|
|
class _SyntheticBanner extends StatelessWidget {
|
|
const _SyntheticBanner();
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
return Container(
|
|
height: 20,
|
|
alignment: Alignment.center,
|
|
color: Colors.black.withValues(alpha: 0.62),
|
|
padding: const EdgeInsets.symmetric(horizontal: 4),
|
|
child: Row(
|
|
mainAxisSize: MainAxisSize.min,
|
|
children: [
|
|
const Icon(Icons.auto_awesome, size: 12, color: Colors.white),
|
|
const SizedBox(width: 4),
|
|
Flexible(
|
|
child: Text(
|
|
_syntheticBadge(context),
|
|
maxLines: 1,
|
|
overflow: TextOverflow.ellipsis,
|
|
style: const TextStyle(fontSize: 12, color: Colors.white),
|
|
),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
}
|
|
}
|
|
|
|
/// R6, part 2: the full sentence, immediately under the image.
|
|
class _SyntheticCaption extends StatelessWidget {
|
|
/// Contrast variant only. The TEXT is the same in both cases; there is no
|
|
/// parameter that can shorten, blank or restyle it away.
|
|
final bool onDark;
|
|
|
|
/// Size of the bitstream this image was reconstructed from.
|
|
final int bytes;
|
|
|
|
const _SyntheticCaption({required this.bytes, this.onDark = false});
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
return Padding(
|
|
padding: const EdgeInsets.only(top: 4),
|
|
child: Text(
|
|
_syntheticCaptionFor(context, bytes),
|
|
// No maxLines: the bubble is narrow and the sentence must never be
|
|
// truncated. A label that reads "Details are invented. Not a" is worse
|
|
// than none — it clips exactly where the warning was going.
|
|
softWrap: true,
|
|
style: TextStyle(
|
|
fontSize: 12,
|
|
color: onDark
|
|
? Colors.white70
|
|
: Theme.of(context).colorScheme.onSurfaceVariant,
|
|
),
|
|
),
|
|
);
|
|
}
|
|
}
|
|
|
|
/// Full-screen view. Private to this file so no other widget can present the
|
|
/// pixels without the two R6 elements.
|
|
class _ReceivedImageViewer extends StatelessWidget {
|
|
final Uint8List png;
|
|
final bool synthesized;
|
|
|
|
/// Bitstream size, so the full-screen caption quotes the same real number as
|
|
/// the one in the transcript.
|
|
final int bytes;
|
|
|
|
/// Source shape (w/h) to undo the sender's stretch, as in the bubble. Null
|
|
/// means square or unknown.
|
|
final double? aspectRatio;
|
|
|
|
const _ReceivedImageViewer({
|
|
required this.png,
|
|
required this.synthesized,
|
|
required this.bytes,
|
|
this.aspectRatio,
|
|
});
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
// Light system bar icons over the black viewer, whatever the app theme.
|
|
return AnnotatedRegion<SystemUiOverlayStyle>(
|
|
value: SystemUiOverlayStyle.light,
|
|
child: Scaffold(
|
|
backgroundColor: Colors.black,
|
|
appBar: AppBar(
|
|
backgroundColor: Colors.black,
|
|
foregroundColor: Colors.white,
|
|
systemOverlayStyle: SystemUiOverlayStyle.light,
|
|
),
|
|
body: Center(
|
|
child: Column(
|
|
mainAxisSize: MainAxisSize.min,
|
|
children: [
|
|
Flexible(
|
|
child: Stack(
|
|
children: [
|
|
InteractiveViewer(
|
|
// fill inside the original aspect box: the exact
|
|
// inverse of the sender's stretch, as in the bubble.
|
|
child: AspectRatio(
|
|
aspectRatio: aspectRatio ?? 1,
|
|
child: Image.memory(png, fit: BoxFit.fill),
|
|
),
|
|
),
|
|
if (synthesized)
|
|
const Positioned(
|
|
left: 0,
|
|
right: 0,
|
|
bottom: 0,
|
|
child: _SyntheticBanner(),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
if (synthesized)
|
|
Padding(
|
|
padding: const EdgeInsets.symmetric(horizontal: 16),
|
|
child: _SyntheticCaption(bytes: bytes, onDark: true),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
),
|
|
);
|
|
}
|
|
}
|