IKAR/lib/core/utils/media_saver.dart

import 'dart:io';

import 'package:flutter/foundation.dart';
import 'package:path_provider/path_provider.dart';
import 'package:photo_manager/photo_manager.dart';

import '../../l10n/app_localizations.dart';
import '../config/device_profile.dart';
import 'download_history.dart';
import 'image_format.dart';
import 'media_cache.dart';

enum MediaSaveFailure { noLink, downloadFailed, fileNotFound, noGalleryAccess }

// #***! итог сохранения, в галерею или в папку
class MediaSaveResult {
  final bool ok;
  final bool toGallery;
  final String? location;
  final MediaSaveFailure? failure;
  final String? error;

  const MediaSaveResult({
    required this.ok,
    this.toGallery = false,
    this.location,
    this.failure,
    this.error,
  });

  String errorText(AppLocalizations l10n) => switch (failure) {
    MediaSaveFailure.noLink => l10n.photoViewerErrorNoLink,
    MediaSaveFailure.downloadFailed => l10n.fileBubbleDownloadFailedReason,
    MediaSaveFailure.fileNotFound => l10n.mediaSaveFileNotFound,
    MediaSaveFailure.noGalleryAccess => l10n.mediaSaveNoGalleryAccess,
    null => error ?? '',
  };
}

// #***! аватарка, качаем в кэш и в галерею
Future<MediaSaveResult> saveImageFromUrl(String url) async {
  if (url.isEmpty) {
    return const MediaSaveResult(ok: false, failure: MediaSaveFailure.noLink);
  }
  try {
    final cacheName = 'avatar_${url.hashCode & 0x7fffffff}.jpg';
    final file = await MediaCache.getOrDownload(cacheName, url);
    if (file == null) {
      return const MediaSaveResult(
        ok: false,
        failure: MediaSaveFailure.downloadFailed,
      );
    }
    return await _persist(
      file,
      saveName: 'avatar_${DateTime.now().millisecondsSinceEpoch}.jpg',
      kind: SaveMediaKind.image,
    );
  } catch (e) {
    return MediaSaveResult(ok: false, error: e.toString());
  }
}

// #***! фото и видео в галерею, остальное в папку
enum SaveMediaKind { image, video, file }

bool get savesToGallery => !kIsWeb && (Platform.isAndroid || Platform.isIOS);

const _scopedStorageSdk = 29;

// #***! сохранение вложения с записью в историю
Future<MediaSaveResult> saveMediaFile({
  required String cacheName,
  required Future<String?> Function() resolveUrl,
  required String saveName,
  required SaveMediaKind kind,
  DownloadMetadata? download,
}) async {
  try {
    var file = await MediaCache.existing(cacheName);
    if (file == null) {
      final url = await resolveUrl();
      if (url == null || url.isEmpty) {
        return const MediaSaveResult(
          ok: false,
          failure: MediaSaveFailure.noLink,
        );
      }
      file = await MediaCache.getOrDownload(cacheName, url);
    }
    if (file == null) {
      return const MediaSaveResult(
        ok: false,
        failure: MediaSaveFailure.downloadFailed,
      );
    }
    final result = await _persist(file, saveName: saveName, kind: kind);
    if (result.ok && download != null) {
      try {
        await DownloadHistory.record(download, file);
      } catch (_) {}
    }
    return result;
  } catch (e) {
    return MediaSaveResult(ok: false, error: e.toString());
  }
}

// #***! медиа уже на диске, просто копируем
Future<MediaSaveResult> saveLocalMedia(
  File file, {
  required String saveName,
  required SaveMediaKind kind,
}) async {
  try {
    if (!await file.exists()) {
      return const MediaSaveResult(
        ok: false,
        failure: MediaSaveFailure.fileNotFound,
      );
    }
    return await _persist(file, saveName: saveName, kind: kind);
  } catch (e) {
    return MediaSaveResult(ok: false, error: e.toString());
  }
}

// #***! на мобилках просим доступ и в галерею, на десктопе в загрузки
Future<MediaSaveResult> _persist(
  File file, {
  required String saveName,
  required SaveMediaKind kind,
}) async {
  if (kind != SaveMediaKind.image) {
    return _write(file, saveName: saveName, kind: kind);
  }
  final image = await prepareImageForSave(file);
  if (image == null) return _write(file, saveName: saveName, kind: kind);
  try {
    return await _write(
      image.file,
      saveName: withImageExtension(saveName, image.extension),
      kind: kind,
    );
  } finally {
    await image.discard();
  }
}

Future<MediaSaveResult> _write(
  File file, {
  required String saveName,
  required SaveMediaKind kind,
}) async {
  final toGallery = kind == SaveMediaKind.image || kind == SaveMediaKind.video;
  if (savesToGallery && toGallery) {
    if (!await _mayWriteGallery()) {
      return const MediaSaveResult(
        ok: false,
        failure: MediaSaveFailure.noGalleryAccess,
      );
    }
    if (kind == SaveMediaKind.video) {
      await PhotoManager.editor.saveVideo(file, title: saveName);
    } else {
      final bytes = await file.readAsBytes();
      await PhotoManager.editor.saveImage(bytes, filename: saveName);
    }
    return const MediaSaveResult(ok: true, toGallery: true);
  }

  final dir = await _targetDirectory();
  final target = File('${dir.path}${Platform.pathSeparator}$saveName');
  await file.copy(target.path);
  return MediaSaveResult(ok: true, location: target.path);
}

Future<bool> _mayWriteGallery() async {
  if (Platform.isAndroid) {
    final sdkInt = (await DeviceProfile.load()).sdkInt ?? 0;
    if (sdkInt >= _scopedStorageSdk) return true;
  }
  final state = await PhotoManager.requestPermissionExtend();
  return state.isAuth || state.hasAccess;
}

// #***! папка загрузок есть не везде, иначе документы приложения
Future<Directory> _targetDirectory() async {
  try {
    final downloads = await getDownloadsDirectory();
    if (downloads != null) return downloads;
  } catch (_) {}
  return getApplicationDocumentsDirectory();
}