only-bible-app v3.7.2+24

import "dart:async";

import "dart:convert";

import "package:flutter/foundation.dart";

import "package:flutter/material.dart";

import "package:flutter/scheduler.dart";

import "package:http/http.dart" as http;

/// Sends (or otherwise records) a single error report. Implementations

/// should be best-effort — a failed report must never throw back into the

/// error handler that triggered it.

typedef ErrorReportSender =

    Future<void> Function(String message, StackTrace? stack);

/// Global crash/error reporting: wires [FlutterError.onError] (framework

/// errors) and [PlatformDispatcher.onError] (uncaught async/platform

/// errors), shows a user-consent dialog before reporting in release builds,

/// and just logs to the console in debug builds.

class ErrorReporting {

  ErrorReporting._();

  static GlobalKey<NavigatorState>? _navigatorKey;

  static ErrorReportSender? _onReport;

  static Set<String> _ignoredSubstrings = const {};

  /// Call once at app startup, after `runApp`'s `navigatorKey` exists.

  static void install({

    required GlobalKey<NavigatorState> navigatorKey,

    required ErrorReportSender onReport,

    Set<String> ignoredSubstrings = const {},

  }) {

    _navigatorKey = navigatorKey;

    _onReport = onReport;

    _ignoredSubstrings = ignoredSubstrings;

    FlutterError.onError = (errorDetails) {

      FlutterError.presentError(errorDetails);

      _handle(errorDetails.exception.toString(), errorDetails.stack);

    };

    PlatformDispatcher.instance.onError = (error, stack) {

      _handle(error.toString(), stack);

      return true;

    };

  }

  /// Manually reports [message] through the same sender configured via

  /// [install], bypassing the consent dialog — for call sites that already

  /// caught and handled a specific error and just want it recorded (e.g.

  /// only-bible-app's audio-playback failure handler).

  static Future<void> report(String message, StackTrace? stack) async {

    if (kDebugMode) {

      debugPrint("Error: $message");

      debugPrint("$stack");

      return;

    }

    await _onReport?.call(message, stack);

  }

  static void _handle(String message, StackTrace? stack) {

    if (kDebugMode) {

      debugPrint("Error: $message");

      debugPrint("$stack");

      return;

    }

    if (_ignoredSubstrings.any(message.contains)) {

      // Known framework noise: still recorded for visibility, just not

      // worth interrupting the user with a dialog they can't act on.

      unawaited(_onReport?.call(message, stack));

      return;

    }

    SchedulerBinding.instance.addPostFrameCallback((_) {

      final context = _navigatorKey?.currentContext;

      if (context == null || !context.mounted) return;

      _showReportDialog(context, message, stack);

    });

  }

  static void _showReportDialog(

    BuildContext context,

    String message,

    StackTrace? stack,

  ) {

    showDialog<void>(

      context: context,

      barrierColor: Colors.black54,

      builder: (dialogContext) => AlertDialog(

        title: const Text("Alert"),

        content: const Text(

          "An error has occurred. Do you want to report this error to us?",

        ),

        actionsAlignment: MainAxisAlignment.end,

        actionsOverflowButtonSpacing: 8.0,

        actions: [

          TextButton(

            onPressed: () {

              Navigator.of(dialogContext).pop();

              unawaited(_onReport?.call(message, stack));

            },

            child: const Text("Yes"),

          ),

          TextButton(

            onPressed: () => Navigator.of(dialogContext).pop(),

            child: const Text("No"),

          ),

        ],

      ),

    );

  }

}

/// Builds an [ErrorReportSender] that POSTs to the shared `error-reporter`

/// Cloudflare Worker (see workers/error-reporter/), which emails the report

/// via Cloudflare Email Sending. [sharedSecret], if provided, is sent as

/// `X-Report-Secret` — this is NOT a real security boundary (it's embedded

/// client-side, same as any app secret), it only filters out generic bots

/// blindly probing the endpoint. Real abuse resistance is the Worker's own

/// rate limiter.

ErrorReportSender httpErrorReportSender({

  required Uri endpoint,

  required String appName,

  String? sharedSecret,

  String? appVersion,

  String? buildNumber,

}) {

  return (message, stack) async {

    try {

      await http.post(

        endpoint,

        headers: {

          "Content-Type": "application/json",

          if (sharedSecret != null) "X-Report-Secret": sharedSecret,

        },

        body: jsonEncode({

          "app": appName,

          "message": message,

          "stack": stack?.toString(),

          "platform": defaultTargetPlatform.name,

          "appVersion": appVersion,

          "buildNumber": buildNumber,

        }),

      );

    } catch (_) {

      // Best-effort — a failed report must not cascade into another error.

    }

  };

}