only-bible-app v3.7.2+24

import "dart:convert";

import "dart:io";

import "package:async_redux/async_redux.dart";

import "package:file_selector/file_selector.dart";

import "package:flutter/foundation.dart";

import "package:flutter/material.dart";

import "package:only_bible_app/dialog.dart";

import "package:only_bible_app/gen/bible.gen.dart";

import "package:only_bible_app/store/app_state.dart";

import "package:only_bible_app/utils.dart";

import "package:path_provider/path_provider.dart";

import "package:share_plus/share_plus.dart";

String buildBackupFileName([DateTime? now]) {

  final n = now ?? DateTime.now();

  final y = n.year.toString().padLeft(4, "0");

  final m = n.month.toString().padLeft(2, "0");

  final d = n.day.toString().padLeft(2, "0");

  return "only_bible_app_backup_$y-$m-$d.json";

}

String buildBackupJson(AppState state) {

  return const JsonEncoder.withIndent("  ").convert(state.toJson());

}

class BackupParseException implements Exception {

  final String message;

  const BackupParseException(this.message);

  @override

  String toString() => message;

}

Future<AppState> parseBackupState(

  String contents, {

  Future<Bible> Function(String) loadBibleFn = loadBible,

}) async {

  final Map<String, dynamic> json;

  try {

    final decoded = jsonDecode(contents);

    if (decoded is! Map<String, dynamic>) {

      throw const FormatException("backup is not a JSON object");

    }

    json = decoded;

  } catch (_) {

    throw const BackupParseException("That file isn't a valid backup");

  }

  final bibleName = json["bibleName"] as String? ?? "en_kjv";

  final Bible bible;

  try {

    bible = await loadBibleFn(bibleName);

  } catch (_) {

    throw const BackupParseException("That file isn't a valid backup");

  }

  try {

    return AppState.fromJson(json, bible);

  } catch (_) {

    throw const BackupParseException("That file isn't a valid backup");

  }

}

class ExportAppStateAction extends ReduxAction<AppState> {

  final BuildContext buildContext;

  ExportAppStateAction(this.buildContext);

  @override

  Future<AppState?> reduce() async {

    final jsonString = buildBackupJson(state);

    final fileName = buildBackupFileName();

    // file_selector's save-location dialog isn't supported on Android/iOS

    // (only desktop and web), so mobile exports go through the share sheet

    // (Save to Files, AirDrop, etc.) instead.

    final canPickSaveLocation = kIsWeb || isDesktop;

    try {

      if (canPickSaveLocation) {

        final location = await getSaveLocation(

          suggestedName: fileName,

          acceptedTypeGroups: const [

            XTypeGroup(label: "JSON", extensions: ["json"]),

          ],

        );

        if (location == null) return null; // user cancelled

        final file = XFile.fromData(

          utf8.encode(jsonString),

          mimeType: "application/json",

          name: fileName,

        );

        await file.saveTo(location.path);

      } else {

        final dir = await getTemporaryDirectory();

        final path = "${dir.path}/$fileName";

        await File(path).writeAsString(jsonString);

        final result = await SharePlus.instance.share(

          ShareParams(files: [XFile(path)]),

        );

        if (result.status == ShareResultStatus.dismissed) return null;

      }

    } catch (_) {

      if (buildContext.mounted) {

        showError(buildContext, "Failed to export backup");

      }

      return null;

    }

    if (buildContext.mounted) {

      showAlert(

        buildContext,

        "Backup Exported",

        "Your backup was saved successfully.",

      );

    }

    return null;

  }

}

class ImportAppStateAction extends ReduxAction<AppState> {

  final BuildContext buildContext;

  ImportAppStateAction(this.buildContext);

  @override

  Future<AppState?> reduce() async {

    final confirmed = await showConfirm(

      buildContext,

      "Import Backup",

      "This will replace all your current highlights and settings. Continue?",

    );

    if (!confirmed) return null;

    if (!buildContext.mounted) return null;

    final file = await openFile(

      acceptedTypeGroups: const [

        XTypeGroup(label: "JSON", extensions: ["json"]),

      ],

    );

    if (file == null) return null; // user cancelled

    try {

      final bytes = await file.readAsBytes();

      final newState = await parseBackupState(utf8.decode(bytes));

      if (buildContext.mounted) {

        showAlert(

          buildContext,

          "Backup Imported",

          "Your backup was restored successfully.",

        );

      }

      return newState;

    } on BackupParseException catch (err) {

      if (buildContext.mounted) {

        showError(buildContext, err.message);

      }

      return null;

    } catch (_) {

      if (buildContext.mounted) {

        showError(buildContext, "That file isn't a valid backup");

      }

      return null;

    }

  }

}