ente/lib/utils/file_uploader.dart

import 'dart:async';
import 'dart:collection';
import 'dart:convert';
import 'dart:io' as io;
import 'package:dio/dio.dart';
import 'package:flutter_sodium/flutter_sodium.dart';
import 'package:logging/logging.dart';
import 'package:photos/core/configuration.dart';
import 'package:photos/core/constants.dart';
import 'package:photos/models/file.dart';
import 'package:photos/models/location.dart';
import 'package:photos/models/upload_url.dart';
import 'package:photos/services/collections_service.dart';
import 'package:photos/utils/crypto_util.dart';

class FileUploader {
  final _logger = Logger("FileUploader");
  final _dio = Dio();
  final _queue = LinkedHashMap<int, FileUploadItem>();
  final _maximumConcurrentUploads = 4;
  int _currentlyUploading = 0;

  FileUploader._privateConstructor();
  static FileUploader instance = FileUploader._privateConstructor();

  Future<File> addToQueue(File file) {
    if (_queue[file.generatedID] == null) {
      _queue[file.generatedID] = FileUploadItem(file, Completer<File>());
      _pollQueue();
    }
    return _queue[file.generatedID].completer.future;
  }

  Future<File> getCurrentUploadStatus(File file) {
    return _queue[file.generatedID]?.completer?.future;
  }

  Future<File> forceUpload(File file) async {
    return _encryptAndUploadFile(file, forcedUpload: true);
  }

  void _pollQueue() {
    if (_queue.length > 0 && _currentlyUploading < _maximumConcurrentUploads) {
      final firstPendingEntry = _queue.entries
          .firstWhere((entry) => entry.value.status == UploadStatus.not_started)
          .value;
      firstPendingEntry.status = UploadStatus.in_progress;
      _encryptAndUploadFile(firstPendingEntry.file);
    }
  }

  Future<File> _encryptAndUploadFile(File file,
      {bool forcedUpload = false}) async {
    _logger.info("Uploading " + file.toString());
    if (!forcedUpload) {
      _currentlyUploading++;
    }
    final encryptedFileName = file.generatedID.toString() + ".encrypted";
    final tempDirectory = Configuration.instance.getTempDirectory();
    final encryptedFilePath = tempDirectory + encryptedFileName;

    final sourceFile = (await (await file.getAsset()).originFile);
    final encryptedFile = io.File(encryptedFilePath);
    final fileAttributes =
        await CryptoUtil.encryptFile(sourceFile.path, encryptedFilePath);

    final fileUploadURL = await _getUploadURL();
    String fileObjectKey = await _putFile(fileUploadURL, encryptedFile);

    final thumbnailData = (await (await file.getAsset()).thumbDataWithSize(
      THUMBNAIL_LARGE_SIZE,
      THUMBNAIL_LARGE_SIZE,
      quality: 50,
    ));
    final encryptedThumbnailName =
        file.generatedID.toString() + "_thumbnail.encrypted";
    final encryptedThumbnailPath = tempDirectory + encryptedThumbnailName;
    final encryptedThumbnailData =
        CryptoUtil.encryptChaCha(thumbnailData, fileAttributes.key);
    final encryptedThumbnail = io.File(encryptedThumbnailPath);
    encryptedThumbnail.writeAsBytesSync(encryptedThumbnailData.encryptedData);

    final thumbnailUploadURL = await _getUploadURL();
    String thumbnailObjectKey =
        await _putFile(thumbnailUploadURL, encryptedThumbnail);

    // h4ck to fetch location data if missing (thank you Android Q+) lazily only during uploads
    if (file.location.latitude == 0 && file.location.longitude == 0) {
      final latLong = await (await file.getAsset()).latlngAsync();
      file.location = Location(latLong.latitude, latLong.longitude);
    }

    final encryptedMetadataData = CryptoUtil.encryptChaCha(
        utf8.encode(jsonEncode(file.getMetadata())), fileAttributes.key);

    final encryptedFileKeyData = CryptoUtil.encryptSync(
      fileAttributes.key,
      CollectionsService.instance.getCollectionKey(file.collectionID),
    );

    final encryptedKey = Sodium.bin2base64(encryptedFileKeyData.encryptedData);
    final keyDecryptionNonce = Sodium.bin2base64(encryptedFileKeyData.nonce);
    final fileDecryptionHeader = Sodium.bin2base64(fileAttributes.header);
    final thumbnailDecryptionHeader =
        Sodium.bin2base64(encryptedThumbnailData.header);
    final encryptedMetadata =
        Sodium.bin2base64(encryptedMetadataData.encryptedData);
    final metadataDecryptionHeader =
        Sodium.bin2base64(encryptedMetadataData.header);

    final data = {
      "collectionID": file.collectionID,
      "encryptedKey": encryptedKey,
      "keyDecryptionNonce": keyDecryptionNonce,
      "file": {
        "objectKey": fileObjectKey,
        "decryptionHeader": fileDecryptionHeader,
      },
      "thumbnail": {
        "objectKey": thumbnailObjectKey,
        "decryptionHeader": thumbnailDecryptionHeader,
      },
      "metadata": {
        "encryptedData": encryptedMetadata,
        "decryptionHeader": metadataDecryptionHeader,
      }
    };
    return _dio
        .post(
      Configuration.instance.getHttpEndpoint() + "/files",
      options:
          Options(headers: {"X-Auth-Token": Configuration.instance.getToken()}),
      data: data,
    )
        .then((response) {
      encryptedFile.deleteSync();
      encryptedThumbnail.deleteSync();
      final data = response.data;
      file.uploadedFileID = data["id"];
      file.updationTime = data["updationTime"];
      file.ownerID = data["ownerID"];
      file.encryptedKey = encryptedKey;
      file.keyDecryptionNonce = keyDecryptionNonce;
      file.fileDecryptionHeader = fileDecryptionHeader;
      file.thumbnailDecryptionHeader = thumbnailDecryptionHeader;
      file.metadataDecryptionHeader = metadataDecryptionHeader;
      if (!forcedUpload) {
        _currentlyUploading--;
        _queue[file.generatedID].completer.complete(file);
        _queue.remove(file.generatedID);
        _pollQueue();
      }
      return file;
    });
  }

  Future<UploadURL> _getUploadURL() {
    return Dio()
        .get(
          Configuration.instance.getHttpEndpoint() + "/files/upload-url",
          options: Options(
              headers: {"X-Auth-Token": Configuration.instance.getToken()}),
        )
        .then((response) => UploadURL.fromMap(response.data));
  }

  Future<String> _putFile(UploadURL uploadURL, io.File file) async {
    final fileSize = file.lengthSync().toString();
    final startTime = DateTime.now().millisecondsSinceEpoch;
    _logger.info("Putting file of size " + fileSize + " to " + uploadURL.url);
    return Dio()
        .put(uploadURL.url,
            data: file.openRead(),
            options: Options(headers: {
              Headers.contentLengthHeader: await file.length(),
            }))
        .catchError((e) {
      _logger.severe(e);
      throw e;
    }).then((value) {
      _logger.info("Upload speed : " +
          (file.lengthSync() /
                  (DateTime.now().millisecondsSinceEpoch - startTime))
              .toString() +
          " kilo bytes per second");
      return uploadURL.objectKey;
    });
  }
}

class FileUploadItem {
  final File file;
  final Completer<File> completer;
  UploadStatus status;

  FileUploadItem(
    this.file,
    this.completer, {
    this.status = UploadStatus.not_started,
  });
}

enum UploadStatus {
  not_started,
  in_progress,
  completed,
}