Javier Bautista Fernández
0b7919e72e
Verificacion silenciosa en segundo plano con queryPastPurchases, al abrir o volver a la app y al cargar Android Auto. Solo revoca tras dos respuestas validas de Play sin la compra separadas 12h; sin red o con error no toca nada. Reactiva el PRO automaticamente si Play confirma la compra.
263 lines
11 KiB
Dart
263 lines
11 KiB
Dart
import 'dart:async';
|
|
|
|
import 'package:flutter/foundation.dart';
|
|
import 'package:shared_preferences/shared_preferences.dart';
|
|
|
|
import '../servicios/servicio_audio.dart' show invalidarArbolAuto;
|
|
import '../servicios/servicio_compras.dart';
|
|
import '../servicios/verificacion_licencia.dart';
|
|
|
|
/// Versioned persistence key (Design ADR-1) for the permanent, non-consumable
|
|
/// premium unlock. Older builds that predate this key simply never read it —
|
|
/// no migration needed (Rollout "Versioned key ... is ignored by older
|
|
/// builds"). Shared with the silent license re-verification
|
|
/// (`verificacion_licencia.dart`), which may revoke it after a refund.
|
|
const _keyPremium = claveCompraPremium;
|
|
|
|
/// Headless-safe entitlement read (Design ADR-1, Spec "Headless-Safe
|
|
/// Entitlement Read"): resolves the persisted premium flag directly from
|
|
/// prefs, with NO `BuildContext`/`Provider` dependency. Mirrors
|
|
/// `FuenteMusicaLocalAutoImpl._resolverPrefs()`'s
|
|
/// inject-or-`getInstance()` convention (`musica_local_auto.dart:163`) —
|
|
/// this is what `PluriWaveAudioHandler` calls, since it registers before
|
|
/// `runApp` and no widget tree (therefore no `Provider`) exists yet.
|
|
///
|
|
/// Absent key = free tier (Rollout "Additive and prefs-backed; absent key =
|
|
/// free"). Never throws — a `SharedPreferences.getInstance()` failure would
|
|
/// propagate here exactly like the persisted read failing, which the caller
|
|
/// (Design ADR-2 "fail-open") must treat as "trust the last known state",
|
|
/// not this function's job to catch.
|
|
Future<bool> esPremiumPersistido({SharedPreferences? prefs}) async {
|
|
final resueltas = prefs ?? await SharedPreferences.getInstance();
|
|
return resueltas.getBool(_keyPremium) ?? false;
|
|
}
|
|
|
|
/// User-facing, non-error-text outcomes [EstadoEntitlement] can expose (FIX
|
|
/// 3, code review): the UI layer (`hoja_premium.dart`) has no BuildContext
|
|
/// here, so this file never carries localized/user-facing STRINGS itself —
|
|
/// only this typed signal, mapped to a localized message by the widget.
|
|
/// Cleared back to `null` once consumed ([EstadoEntitlement.consumirResultadoUsuario]).
|
|
enum ResultadoEntitlementUsuario {
|
|
/// A purchase or restore attempt failed (network, billing error, product
|
|
/// not yet available in the store, etc). This NEVER carries the raw
|
|
/// exception/developer string from [EventoCompra.mensaje] — the UI maps
|
|
/// this enum value to ONE generic localized message, never the internal
|
|
/// diagnostic text.
|
|
error,
|
|
|
|
/// [EstadoEntitlement.restaurar] completed successfully but found nothing
|
|
/// to restore. Distinct from [error]: an expected, non-error outcome
|
|
/// (Spec "Restore Purchases" — "finds nothing -> stays free tier with a
|
|
/// clear non-error result").
|
|
restauracionSinCompras,
|
|
}
|
|
|
|
/// Cross-cutting entitlement notifier (Design ADR-1), idiomatic
|
|
/// `EstadoIdioma`-shaped `ChangeNotifier`: UI layers `context.watch`/`read`
|
|
/// this; headless callers (Android Auto) use [esPremiumPersistido] instead,
|
|
/// since no `Provider` exists on that path.
|
|
class EstadoEntitlement extends ChangeNotifier {
|
|
EstadoEntitlement({
|
|
SharedPreferences? prefs,
|
|
PuertoCompras? compras,
|
|
DateTime Function()? reloj,
|
|
}) : _prefs = prefs,
|
|
_compras = compras,
|
|
_reloj = reloj {
|
|
final flujo = _compras;
|
|
if (flujo != null) {
|
|
_comprasSub = flujo.eventos.listen(_alRecibirEvento);
|
|
}
|
|
// The silent license check is chained AFTER the load and never awaited
|
|
// by anyone: the persisted flag is served immediately, exactly as
|
|
// before, and the check can only adjust it later, in the background.
|
|
unawaited(_cargar().then((_) => _verificarLicencia()));
|
|
}
|
|
|
|
/// The single non-consumable product id (Design "Interfaces / Contracts"),
|
|
/// re-exported here so UI/paywall code depends on ONE canonical constant
|
|
/// rather than reaching into `servicio_compras.dart` for it.
|
|
static const idProducto = ServicioComprasPlayBilling.idProducto;
|
|
|
|
final SharedPreferences? _prefs;
|
|
final PuertoCompras? _compras;
|
|
|
|
/// Injectable clock for the license check's throttle/spacing rules.
|
|
final DateTime Function()? _reloj;
|
|
StreamSubscription<EventoCompra>? _comprasSub;
|
|
bool _desechado = false;
|
|
|
|
bool _esPremium = false;
|
|
bool _compraEnCurso = false;
|
|
ResultadoEntitlementUsuario? _resultadoUsuario;
|
|
|
|
bool get esPremium => _esPremium;
|
|
bool get compraEnCurso => _compraEnCurso;
|
|
|
|
/// FIX 3 (code review): the user-facing signal for a failed purchase/
|
|
/// restore, or a restore that found nothing. `null` when there is nothing
|
|
/// to show — see [consumirResultadoUsuario].
|
|
ResultadoEntitlementUsuario? get resultadoUsuario => _resultadoUsuario;
|
|
|
|
/// Clears [resultadoUsuario] once the UI has consumed/displayed it.
|
|
/// A no-op (no extra notification) if there is nothing to clear.
|
|
void consumirResultadoUsuario() {
|
|
if (_resultadoUsuario == null) return;
|
|
_resultadoUsuario = null;
|
|
notifyListeners();
|
|
}
|
|
|
|
Future<void> _cargar() async {
|
|
final prefs = await _resolverPrefs();
|
|
final premium = prefs.getBool(_keyPremium) ?? false;
|
|
if (premium != _esPremium) {
|
|
_esPremium = premium;
|
|
}
|
|
notifyListeners();
|
|
}
|
|
|
|
Future<SharedPreferences> _resolverPrefs() async =>
|
|
_prefs ?? SharedPreferences.getInstance();
|
|
|
|
/// Fire-and-forget hook for app resume: re-syncs with the persisted flag
|
|
/// (the Android Auto path may have changed it) and runs the throttled
|
|
/// silent license check. Never throws, never touches [compraEnCurso] or
|
|
/// [resultadoUsuario].
|
|
Future<void> refrescarLicencia() async {
|
|
try {
|
|
_sincronizarConPrefs(await _resolverPrefs());
|
|
} catch (e) {
|
|
debugPrint('[PluriWave][licencia] refresco fallido $e');
|
|
}
|
|
await _verificarLicencia();
|
|
}
|
|
|
|
/// Runs [verificarLicencia] against the purchase port and mirrors any
|
|
/// change of the persisted flag. Silent by construction: it only ever
|
|
/// updates [esPremium] and notifies — no purchase-stream event, no
|
|
/// [resultadoUsuario], no [compraEnCurso].
|
|
Future<void> _verificarLicencia() async {
|
|
final compras = _compras;
|
|
if (compras == null || _desechado) return;
|
|
try {
|
|
final prefs = await _resolverPrefs();
|
|
await verificarLicencia(
|
|
consultar: compras.consultarPropiedad,
|
|
prefs: prefs,
|
|
reloj: _reloj,
|
|
);
|
|
_sincronizarConPrefs(prefs);
|
|
} catch (e) {
|
|
debugPrint('[PluriWave][licencia] verificacion fallida $e');
|
|
}
|
|
}
|
|
|
|
/// Aligns [esPremium] with the persisted flag. Safe against a racing
|
|
/// [_desbloquear]: that one writes the prefs cache in the same synchronous
|
|
/// block where it flips [_esPremium], so both always agree here.
|
|
void _sincronizarConPrefs(SharedPreferences prefs) {
|
|
if (_desechado) return;
|
|
final premium = prefs.getBool(_keyPremium) ?? false;
|
|
if (premium == _esPremium) return;
|
|
_esPremium = premium;
|
|
notifyListeners();
|
|
// Either direction changes what the car may show (local music is
|
|
// premium-gated), so the cached Android Auto tree is stale both ways.
|
|
invalidarArbolAuto();
|
|
}
|
|
|
|
/// Starts the purchase flow (Spec "Successful purchase"). A no-op when
|
|
/// already premium (Spec "Already-purchased attempt is idempotent") — no
|
|
/// duplicate charge is even attempted.
|
|
Future<void> comprar() async {
|
|
if (_esPremium) return;
|
|
final compras = _compras;
|
|
if (compras == null) return;
|
|
_compraEnCurso = true;
|
|
// FIX 3 (code review): a fresh attempt clears any stale result left over
|
|
// from a previous failed attempt, so the UI never shows an outdated
|
|
// error/confirmation across two unrelated attempts.
|
|
_resultadoUsuario = null;
|
|
notifyListeners();
|
|
await compras.comprar();
|
|
}
|
|
|
|
/// Re-queries Play Billing for a prior purchase (Spec "Restore Purchases").
|
|
Future<void> restaurar() async {
|
|
final compras = _compras;
|
|
if (compras == null) return;
|
|
_compraEnCurso = true;
|
|
_resultadoUsuario = null;
|
|
notifyListeners();
|
|
await compras.restaurar();
|
|
}
|
|
|
|
Future<void> _alRecibirEvento(EventoCompra evento) async {
|
|
switch (evento.tipo) {
|
|
case TipoEventoCompra.comprada:
|
|
case TipoEventoCompra.restaurada:
|
|
await _desbloquear();
|
|
case TipoEventoCompra.cancelada:
|
|
// Spec "Purchase cancelled or failed": a user-INITIATED cancel
|
|
// stays free tier with no error surfaced — just stop the in-flight
|
|
// spinner. Not a failure, so no [resultadoUsuario] either.
|
|
_compraEnCurso = false;
|
|
notifyListeners();
|
|
case TipoEventoCompra.noEncontrada:
|
|
// FIX 3 (code review): "Restore finds nothing" is an expected,
|
|
// NON-error outcome (Spec "Restore Purchases") but `hoja_premium.dart`
|
|
// had zero feedback for it — the spinner just stopped with no
|
|
// confirmation. Distinct signal from [TipoEventoCompra.error].
|
|
_compraEnCurso = false;
|
|
_resultadoUsuario = ResultadoEntitlementUsuario.restauracionSinCompras;
|
|
notifyListeners();
|
|
case TipoEventoCompra.error:
|
|
// Fail-open (Design ADR-2): an error NEVER writes `false` over an
|
|
// already-premium flag, and never invents a `true` for a free user
|
|
// either — the persisted flag from `_cargar()` is left untouched.
|
|
//
|
|
// FIX 3 (code review): [EventoCompra.mensaje] (raw exception/
|
|
// developer text, e.g. "Producto no encontrado en Play Console") is
|
|
// DELIBERATELY discarded here — only the typed enum crosses into
|
|
// [resultadoUsuario], never the raw string. `hoja_premium.dart` maps
|
|
// it to ONE generic localized message.
|
|
_compraEnCurso = false;
|
|
_resultadoUsuario = ResultadoEntitlementUsuario.error;
|
|
notifyListeners();
|
|
case TipoEventoCompra.pendiente:
|
|
_compraEnCurso = true;
|
|
notifyListeners();
|
|
}
|
|
}
|
|
|
|
Future<void> _desbloquear() async {
|
|
// Prefs resolved FIRST so the in-memory flip and the prefs-cache write
|
|
// below happen in one synchronous block (`setBool` updates the cache
|
|
// before awaiting the platform) — [_sincronizarConPrefs] can never
|
|
// observe one without the other.
|
|
final prefs = await _resolverPrefs();
|
|
final yaEraPremium = _esPremium;
|
|
_esPremium = true;
|
|
_compraEnCurso = false;
|
|
final escritura = prefs.setBool(_keyPremium, true);
|
|
// A real purchase/restore is fresh proof of ownership: drop any stale
|
|
// absence streak of the silent license check.
|
|
await reiniciarAusenciasLicencia(prefs);
|
|
await escritura;
|
|
notifyListeners();
|
|
if (!yaEraPremium) {
|
|
// Orchestrator-resolved open question (design.md): actively
|
|
// invalidate the Android Auto browse cache on the free -> premium
|
|
// transition, rather than waiting for the head unit's own re-bind.
|
|
invalidarArbolAuto();
|
|
}
|
|
}
|
|
|
|
@override
|
|
void dispose() {
|
|
_desechado = true;
|
|
_comprasSub?.cancel();
|
|
super.dispose();
|
|
}
|
|
}
|