Warp/apps/mobile/lib/matrix/media.dart

import 'dart:typed_data';

import 'package:matrix/matrix.dart';

/// Loads media for display: avatars by their `mxc://` URI, attachments by
/// their event.
///
/// Media is authenticated (Matrix 1.11), so it can't be handed to an image
/// widget as a URL: it is fetched with the access token here. Attachments go
/// through the SDK, which decrypts files from encrypted rooms and keeps them
/// in its file store; avatars are cached in that store too. A small
/// in-memory cache in front keeps scrolling from refetching.
class Media {
  Media._();

  static const _maxEntries = 300;
  static final _cache = <String, Future<Uint8List?>>{};

  static Future<Uint8List?> _remember(
    String key,
    Future<Uint8List?> Function() load,
  ) {
    final hit = _cache.remove(key);
    if (hit != null) {
      _cache[key] = hit;
      return hit;
    }
    final future = load().catchError((Object e) {
      Logs().v('Could not load $key', e);
      _cache.remove(key);
      return null;
    });
    _cache[key] = future;
    while (_cache.length > _maxEntries) {
      _cache.remove(_cache.keys.first);
    }
    return future;
  }

  /// A square thumbnail of [mxc], [size] logical pixels (fetched at 2x).
  static Future<Uint8List?> thumbnail(Client client, Uri mxc, int size) {
    final px = size * 2 < 96 ? 96 : size * 2;
    return _remember('$mxc@$px', () async {
      final stored = await client.database.getFile(_storeKey(mxc, px));
      if (stored != null) return stored;
      final uri = await mxc.getThumbnailUri(
        client,
        width: px,
        height: px,
        method: ThumbnailMethod.crop,
      );
      final response = await client.httpClient.get(
        uri,
        headers: {'authorization': 'Bearer ${client.accessToken}'},
      );
      if (response.statusCode != 200) return null;
      final bytes = response.bodyBytes;
      await client.database.storeFile(
        _storeKey(mxc, px),
        bytes,
        DateTime.now().millisecondsSinceEpoch,
      );
      return bytes;
    });
  }

  static Uri _storeKey(Uri mxc, int px) =>
      Uri(scheme: 'cache', host: 'avatar', path: '${mxc.host}${mxc.path}@$px');

  /// The attachment of [event], or its thumbnail when it has one and
  /// [thumbnail] is set. Decrypted when the room is encrypted.
  static Future<Uint8List?> attachment(Event event, {bool thumbnail = false}) {
    final useThumb = thumbnail && event.hasThumbnail;
    return _remember(
      '${event.eventId}${useThumb ? '#thumb' : ''}',
      () async => (await event.downloadAndDecryptAttachment(
        getThumbnail: useThumb,
      )).bytes,
    );
  }

  /// Forgets an event's cached attachment, for a retry after a failure.
  static void evict(Event event) {
    _cache.remove(event.eventId);
    _cache.remove('${event.eventId}#thumb');
  }
}