139 lines
4.5 KiB
Dart
139 lines
4.5 KiB
Dart
import 'dart:async';
|
|
|
|
import 'package:flutter/foundation.dart';
|
|
import 'package:flutter/services.dart';
|
|
|
|
import '../modelos/alarma_musical.dart';
|
|
|
|
class EventoAlarmaAndroid {
|
|
const EventoAlarmaAndroid({
|
|
required this.alarmaId,
|
|
required this.titulo,
|
|
required this.accion,
|
|
});
|
|
|
|
final String alarmaId;
|
|
final String titulo;
|
|
final String accion;
|
|
|
|
factory EventoAlarmaAndroid.fromMap(Map<Object?, Object?> map) {
|
|
return EventoAlarmaAndroid(
|
|
alarmaId: map['alarmId'] as String? ?? '',
|
|
titulo: map['alarmTitle'] as String? ?? 'PluriWave',
|
|
accion: map['alarmAction'] as String? ?? '',
|
|
);
|
|
}
|
|
}
|
|
|
|
class DiagnosticoAlarmasAndroid {
|
|
const DiagnosticoAlarmasAndroid({
|
|
required this.puedeProgramarExactas,
|
|
required this.notificacionesPermitidas,
|
|
required this.fabricante,
|
|
required this.versionSdk,
|
|
});
|
|
|
|
final bool puedeProgramarExactas;
|
|
final bool notificacionesPermitidas;
|
|
final String fabricante;
|
|
final int versionSdk;
|
|
|
|
factory DiagnosticoAlarmasAndroid.fromMap(Map<Object?, Object?> map) {
|
|
return DiagnosticoAlarmasAndroid(
|
|
puedeProgramarExactas: map['canScheduleExactAlarms'] as bool? ?? true,
|
|
notificacionesPermitidas: map['notificationsEnabled'] as bool? ?? true,
|
|
fabricante: map['manufacturer'] as String? ?? 'Android',
|
|
versionSdk: map['sdkInt'] as int? ?? 0,
|
|
);
|
|
}
|
|
}
|
|
|
|
class ServicioAlarmasAndroid {
|
|
ServicioAlarmasAndroid({
|
|
MethodChannel channel = const MethodChannel('pluriwave/alarm_scheduler'),
|
|
}) : _channel = channel {
|
|
_instalarHandler(_channel);
|
|
}
|
|
|
|
final MethodChannel _channel;
|
|
static final _eventosController =
|
|
StreamController<EventoAlarmaAndroid>.broadcast();
|
|
static bool _handlerInstalado = false;
|
|
|
|
Stream<EventoAlarmaAndroid> get eventosAlarma => _eventosController.stream;
|
|
|
|
Future<void> programar(AlarmaMusical alarma) async {
|
|
final proxima = alarma.proximaEjecucion;
|
|
if (proxima == null || !alarma.activa) {
|
|
debugPrint(
|
|
'[PluriWave][alarmas] cancelar por inactiva/sin proxima id=${alarma.id} activa=${alarma.activa} proxima=$proxima',
|
|
);
|
|
await cancelar(alarma.id);
|
|
return;
|
|
}
|
|
debugPrint(
|
|
'[PluriWave][alarmas] programar id=${alarma.id} nombre=${alarma.nombre} proxima=${proxima.toIso8601String()} preaviso=${proxima.subtract(const Duration(minutes: 30)).toIso8601String()}',
|
|
);
|
|
await _channel.invokeMethod<void>('scheduleAlarm', {
|
|
'id': alarma.id,
|
|
'title': alarma.nombre,
|
|
'triggerAtMillis': proxima.millisecondsSinceEpoch,
|
|
'preNoticeAtMillis':
|
|
proxima.subtract(const Duration(minutes: 30)).millisecondsSinceEpoch,
|
|
});
|
|
}
|
|
|
|
Future<void> cancelar(String alarmaId) =>
|
|
_logAndInvokeVoid('cancelAlarm', {'id': alarmaId});
|
|
|
|
Future<void> ocultarNotificacionAlarma(String alarmaId) =>
|
|
_logAndInvokeVoid('dismissAlarmNotification', {'id': alarmaId});
|
|
|
|
Future<DiagnosticoAlarmasAndroid> diagnostico() async {
|
|
debugPrint('[PluriWave][alarmas] diagnostico android');
|
|
final raw = await _channel.invokeMethod<Map<Object?, Object?>>(
|
|
'diagnostics',
|
|
);
|
|
final diag = DiagnosticoAlarmasAndroid.fromMap(raw ?? const {});
|
|
debugPrint(
|
|
'[PluriWave][alarmas] diagnostico exactas=${diag.puedeProgramarExactas} notificaciones=${diag.notificacionesPermitidas} sdk=${diag.versionSdk} fabricante=${diag.fabricante}',
|
|
);
|
|
return diag;
|
|
}
|
|
|
|
Future<EventoAlarmaAndroid?> obtenerEventoInicial() async {
|
|
final raw = await _channel.invokeMethod<Map<Object?, Object?>>(
|
|
'getInitialAlarmIntent',
|
|
);
|
|
if (raw == null || raw.isEmpty) return null;
|
|
final evento = EventoAlarmaAndroid.fromMap(raw);
|
|
debugPrint(
|
|
'[PluriWave][alarmas] evento inicial id=${evento.alarmaId} accion=${evento.accion}',
|
|
);
|
|
return evento.alarmaId.isEmpty ? null : evento;
|
|
}
|
|
|
|
Future<void> _logAndInvokeVoid(String method, Map<String, Object?> args) {
|
|
debugPrint('[PluriWave][alarmas] $method $args');
|
|
return _channel.invokeMethod<void>(method, args);
|
|
}
|
|
|
|
static void _instalarHandler(MethodChannel channel) {
|
|
if (_handlerInstalado) return;
|
|
_handlerInstalado = true;
|
|
channel.setMethodCallHandler((call) async {
|
|
if (call.method != 'alarmFired') return;
|
|
final args = call.arguments;
|
|
if (args is Map) {
|
|
final evento = EventoAlarmaAndroid.fromMap(args);
|
|
if (evento.alarmaId.isNotEmpty) {
|
|
debugPrint(
|
|
'[PluriWave][alarmas] evento nativo id=${evento.alarmaId} accion=${evento.accion}',
|
|
);
|
|
_eventosController.add(evento);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
}
|