Mejorar la valoración de tu app Flutter en el App Store con un buen timing

const MIN_DAYS = 1;        // attendre au moins N jours après install
const MIN_LAUNCHES = 3;    // attendre N lancements de l'app
const REMIND_DAYS = 5;     // laisser N jours entre deux demandes
const REMIND_LAUNCHES = 5; // ou N lancements entre deux demandes

const DAYS_BEFORE_ASK_IN_APP_REVIEW = 30;                 // popup native de note
const DAYS_BEFORE_ASK_IN_APP_REVIEW_FOR_FEEDBACK = 3;     // demande de feedback interne

import 'package:flutter/material.dart';
import 'package:flutter_dotenv/flutter_dotenv.dart';
import 'package:flutter_i18n/flutter_i18n.dart';
import 'package:flutter_riverpod/flutter_riverpod.dart';
import 'package:flutter_screenutil/flutter_screenutil.dart';
import 'package:go_router/go_router.dart';
import 'package:in_app_review/in_app_review.dart';
import 'package:rate_my_app/rate_my_app.dart';
import 'package:riverpod_annotation/riverpod_annotation.dart';
import 'package:flutter/foundation.dart' show kIsWeb;

part 'rate_app_provider.g.dart';

const MIN_DAYS = 1;
const MIN_LAUNCHES = 3;
const REMIND_DAYS = 5;
const REMIND_LAUNCHES = 5;

const DAYS_BEFORE_ASK_IN_APP_REVIEW = 30;
const DAYS_BEFORE_ASK_IN_APP_REVIEW_FOR_FEEDBACK = 3;

/// Provider for the RateMyApp instance
@Riverpod(keepAlive: true)
RateAppService rateAppService(Ref ref) {
  return RateAppService();
}

/// Service class to handle RateMyApp functionality
class RateAppService {
  late final RateMyApp _rateMyApp;
  late final InAppReview _inAppReview;
  final Storage _storage = SharedPreferencesStorage();

  bool _isInitialized = false;

  RateAppService() {
    if (kIsWeb) return;

    _rateMyApp = RateMyApp(
      preferencesPrefix: 'rate_my_app_',
      minDays: MIN_DAYS,
      minLaunches: MIN_LAUNCHES,
      remindDays: REMIND_DAYS,
      remindLaunches: REMIND_LAUNCHES,
      googlePlayIdentifier:
          dotenv.env['ANDROID_APP_ID'],
      appStoreIdentifier: dotenv.env['IOS_APP_ID'],
    );

    _inAppReview = InAppReview.instance;
  }

  /// Initialize the RateMyApp instance
  Future<void> init() async {
    if (kIsWeb || _isInitialized) return;

    await _rateMyApp.init();
    _isInitialized = true;
  }

  /// Check if the rate dialog should be shown
  bool get shouldShowDialog =>
      !kIsWeb && _isInitialized && _rateMyApp.shouldOpenDialog;

  Future<bool> get shouldShowDialogForFeedback async {
    final lastTimeAsked =
        await _storage.read(key: "in_app_review_last_time_asked_for_feedback");

    if (lastTimeAsked != null) {
      final now = DateTime.now();
      final lastTimeAskedInDate = DateTime.parse(lastTimeAsked);
      final difference = now.difference(lastTimeAskedInDate);
      if (difference.inDays < DAYS_BEFORE_ASK_IN_APP_REVIEW_FOR_FEEDBACK) {
        return false;
      }
    }

    await _storage.write(
        key: "in_app_review_last_time_asked_for_feedback",
        value: DateTime.now().toIso8601String());

    return !kIsWeb && _isInitialized;
  }

  /// Show the rate dialog
  Future<void> showRateDialog(BuildContext context) async {
    if (kIsWeb || !_isInitialized) return;

    _rateMyApp.callEvent(RateMyAppEventType.dialogOpen);

    showDialog(
      context: context,
      builder: (context) => RateAppDialog(),
    );
  }

  /// Call a RateMyApp event
  void callEvent(RateMyAppEventType eventType) {
    if (kIsWeb || !_isInitialized) return;
    _rateMyApp.callEvent(eventType);
  }

  // InAppReview
  Future<bool> requestAppReview() async {
    if (kIsWeb || !_isInitialized) return false;

    final lastTimeAsked =
        await _storage.read(key: "in_app_review_last_time_asked");

    if (lastTimeAsked != null) {
      final now = DateTime.now();
      final lastTimeAskedInDate = DateTime.parse(lastTimeAsked);

      final difference = now.difference(lastTimeAskedInDate);
      if (difference.inDays < DAYS_BEFORE_ASK_IN_APP_REVIEW) {
        await launchStore();
        return false;
      }
    }

    if (await _inAppReview.isAvailable()) {
      _inAppReview.requestReview();
      await _storage.write(
          key: "in_app_review_last_time_asked",
          value: DateTime.now().toIso8601String());
      return true;
    }

    await launchStore();
    return false;
  }

  Future<LaunchStoreResult> launchStore() async {
    if (kIsWeb || !_isInitialized) return LaunchStoreResult.errorOccurred;

    return await _rateMyApp.launchStore();
  }
}

enum RateAppStep {
  initial,
  rateApp,
  askForFeedback,
}

import 'package:flutter/material.dart';
import 'package:flutter_i18n/flutter_i18n.dart';
import 'package:flutter_riverpod/flutter_riverpod.dart';
import 'package:flutter_screenutil/flutter_screenutil.dart';
import 'package:go_router/go_router.dart';

class RateAppDialog extends ConsumerStatefulWidget {
  final RateAppStep step;
  const RateAppDialog({
    super.key,
    this.step = RateAppStep.initial,
  });

  @override
  ConsumerState<RateAppDialog> createState() => _RateAppDialogState();
}

class _RateAppDialogState extends ConsumerState<RateAppDialog> {
  RateAppStep _step = RateAppStep.initial;

  @override
  void initState() {
    super.initState();

    _step = widget.step;
  }

  @override
  Widget build(BuildContext context) {
    final theme = Theme.of(context);

    final title = switch (_step) {
      RateAppStep.initial =>
        FlutterI18n.translate(context, "rate_app_dialog.title.initial"),
      RateAppStep.rateApp => FlutterI18n.translate(
          context, "rate_app_dialog.title.rate_app"),
      RateAppStep.askForFeedback => FlutterI18n.translate(
          context, "rate_app_dialog.title.ask_for_feedback"),
    };

    final message = switch (_step) {
      RateAppStep.initial =>
        FlutterI18n.translate(context, "rate_app_dialog.message.initial"),
      RateAppStep.rateApp => FlutterI18n.translate(
          context, "rate_app_dialog.message.rate_app"),
      RateAppStep.askForFeedback => FlutterI18n.translate(
          context, "rate_app_dialog.message.ask_for_feedback"),
    };

    final image = switch (_step) {
      RateAppStep.initial => 'assets/images/dialog/rate-dialog-positive.png',
      RateAppStep.rateApp => 'assets/images/dialog/rate-dialog-positive.png',
      RateAppStep.askForFeedback =>
        'assets/images/dialog/rate-dialog-negative.png',
    };

    final forceOverflow = switch (_step) {
      RateAppStep.initial => false,
      RateAppStep.rateApp => true,
      RateAppStep.askForFeedback => true,
    };

    final buttonYes = switch (_step) {
      RateAppStep.initial => FlutterI18n.translate(
          context, "rate_app_dialog.button_yes.initial"),
      RateAppStep.rateApp => FlutterI18n.translate(
          context, "rate_app_dialog.button_yes.rate_app"),
      RateAppStep.askForFeedback => FlutterI18n.translate(
          context, "rate_app_dialog.button_yes.ask_for_feedback"),
    };

    final buttonNo = switch (_step) {
      RateAppStep.initial => FlutterI18n.translate(
          context, "rate_app_dialog.button_no.initial"),
      RateAppStep.rateApp => FlutterI18n.translate(
          context, "rate_app_dialog.button_no.rate_app"),
      RateAppStep.askForFeedback => FlutterI18n.translate(
          context, "rate_app_dialog.button_no.ask_for_feedback"),
    };

    return AlertDialog(
      contentPadding: EdgeInsets.zero,
      content: Column(
        mainAxisSize: MainAxisSize.min,
        children: [
          Padding(
            padding: const EdgeInsets.fromLTRB(32, 32, 32, 0),
            child: Column(
              crossAxisAlignment: CrossAxisAlignment.center,
              children: [
                Image.asset(
                  image,
                  width: 200.w,
                  height: 200.h,
                ),
                const SizedBox(height: 16),
                Text(title,
                    style: theme.textTheme.headlineSmall,
                    textAlign: TextAlign.center),
                const SizedBox(height: 8),
                Text(message,
                    style: theme.textTheme.bodyMedium?.copyWith(
                          color: theme.colorScheme.onSurface.withOpacity(0.6),
                          fontWeight: FontWeight.w300,
                        ),
                    textAlign: TextAlign.center),
              ],
            ),
          ),
          const SizedBox(height: 24),
          Divider(
            color: theme.dividerColor,
            height: 1,
          ),
        ],
      ),
      actionsAlignment: MainAxisAlignment.spaceBetween,
      actionsPadding: const EdgeInsets.symmetric(
          horizontal: 32, vertical: 24),
      actionsOverflowAlignment: OverflowBarAlignment.center,
      actionsOverflowDirection: VerticalDirection.up,
      actions: [
        TextButton(
          onPressed: () {
            switch (_step) {
              case RateAppStep.initial:
                setState(() {
                  _step = RateAppStep.askForFeedback;
                });
                ref
                    .read(rateAppServiceProvider)
                    .callEvent(RateMyAppEventType.noButtonPressed);
                break;
              case RateAppStep.rateApp:
                ref
                    .read(rateAppServiceProvider)
                    .callEvent(RateMyAppEventType.laterButtonPressed);
                Navigator.of(context).pop(false);
                break;
              case RateAppStep.askForFeedback:
                ref
                    .read(rateAppServiceProvider)
                    .callEvent(RateMyAppEventType.laterButtonPressed);
                Navigator.of(context).pop(false);
                break;
            }
          },
          child: Text(
            buttonNo,
          ),
        ),
        if (forceOverflow)
          const SizedBox(width: 48, height: 8),
        ElevatedButton(
          onPressed: () async {
            switch (_step) {
              case RateAppStep.initial:
                setState(() {
                  _step = RateAppStep.rateApp;
                });

                ref
                    .read(rateAppServiceProvider)
                    .callEvent(RateMyAppEventType.rateButtonPressed);
                await ref.read(rateAppServiceProvider).requestAppReview();
                break;
              case RateAppStep.rateApp:
                ref.read(rateAppServiceProvider);
                Navigator.of(context).pop(false);
                break;
              case RateAppStep.askForFeedback:
                Navigator.of(context).pop(false);
                context.go('/settings/contact/feedback_on_app');
                break;
            }
          },
          child: Text(
            buttonYes,
          ),
        ),
      ],
    );
  }
}

WidgetsBinding.instance.addPostFrameCallback((_) {
  Future.delayed(const Duration(seconds: 5), () async {
    if (!mounted) return;
    final service = ref.read(rateAppServiceProvider);
    if (service.shouldShowDialog) {
      await service.showRateDialog(context);
    }
  });
});

Future<void> onStoryCompleted(BuildContext context, WidgetRef ref) async {
  final service = ref.read(rateAppServiceProvider);
  if (service.shouldShowDialog) {
    await service.showRateDialog(context);
  }
}

context.go('/settings/contact/feedback_on_app');
// dans cet écran : formulaire court, captures optionnelles, consentement, envoi asynchrone.
// Si offline, stocke en local et sync plus tard.

RateMyApp(
  preferencesPrefix: 'rateMyApp_dev_',
  minDays: 0,
  minLaunches: 0,
  remindDays: 1,
  remindLaunches: 1,
  // ...
);