Remakeing application - 2026-01-10 [2]

Author: coderooz

android/.kotlin/sessions/kotlin-compiler-8468629118357355569.salive

@@ -1,7 +1,6 @@
 plugins {
     id("com.android.application")
     id("kotlin-android")
-    // The Flutter Gradle Plugin must be applied after the Android and Kotlin Gradle plugins.
     id("dev.flutter.flutter-gradle-plugin")
 }
 
@@ -13,32 +12,32 @@ android {
     compileOptions {
         sourceCompatibility = JavaVersion.VERSION_17
         targetCompatibility = JavaVersion.VERSION_17
+        isCoreLibraryDesugaringEnabled = true
     }
 
     kotlinOptions {
         jvmTarget = JavaVersion.VERSION_17.toString()
     }
 
     defaultConfig {
-        // TODO: Specify your own unique Application ID (https://developer.android.com/studio/build/application-id.html).
         applicationId = "com.example.note_alarm"
-        // You can update the following values to match your application needs.
-        // For more information, see: https://flutter.dev/to/review-gradle-config.
-        minSdk = flutter.minSdkVersion
+        minSdk = flutter.minSdkVersion // REQUIRED for notifications + desugaring
         targetSdk = flutter.targetSdkVersion
         versionCode = flutter.versionCode
         versionName = flutter.versionName
     }
 
     buildTypes {
         release {
-            // TODO: Add your own signing config for the release build.
-            // Signing with the debug keys for now, so `flutter run --release` works.
             signingConfig = signingConfigs.getByName("debug")
         }
     }
 }
 
+dependencies {
+    coreLibraryDesugaring("com.android.tools:desugar_jdk_libs:2.1.4")
+}
+
 flutter {
     source = "../.."
 }

android/app/build.gradle.kts

@@ -51,4 +51,6 @@
     <uses-permission android:name="android.permission.POST_NOTIFICATIONS"/>
     <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED"/>
     <uses-permission android:name="android.permission.WAKE_LOCK"/>
+    <uses-permission android:name="android.permission.SCHEDULE_EXACT_ALARM"/>
+
 </manifest>

android/app/src/main/AndroidManifest.xml

@@ -4,4 +4,5 @@
          to allow setting breakpoints, to provide hot reload, etc.
     -->
     <uses-permission android:name="android.permission.INTERNET"/>
+    <uses-permission android:name="android.permission.SCHEDULE_EXACT_ALARM"/>
 </manifest>

android/app/src/profile/AndroidManifest.xml

@@ -9,7 +9,7 @@ class NoteAlarmApp extends StatelessWidget {
   @override
   Widget build(BuildContext context) {
     return MaterialApp(
-      title: 'Note-Alarm',
+      title: 'Note Alarm',
       debugShowCheckedModeBanner: false,
       theme: AppTheme.lightTheme,
       home: const HomeShell(),

lib/app.dart

@@ -1,3 +1,4 @@
+import 'dart:io';
 import 'package:flutter_local_notifications/flutter_local_notifications.dart';
 import 'package:timezone/data/latest.dart' as tz;
 import 'package:timezone/timezone.dart' as tz;
@@ -6,18 +7,57 @@ class NotificationService {
   static final FlutterLocalNotificationsPlugin _plugin =
       FlutterLocalNotificationsPlugin();
 
+  /// Initialize notifications + timezone
   static Future<void> init() async {
     tz.initializeTimeZones();
 
     const androidSettings = AndroidInitializationSettings(
       '@mipmap/launcher_icon',
     );
 
-    const initSettings = InitializationSettings(android: androidSettings);
+    const settings = InitializationSettings(android: androidSettings);
 
-    await _plugin.initialize(initSettings);
+    await _plugin.initialize(settings);
+
+    // 🔔 REQUIRED notification channel
+    const channel = AndroidNotificationChannel(
+      'alarm_channel',
+      'Alarm Notifications',
+      description: 'Exact alarm alerts',
+      importance: Importance.max,
+      sound: RawResourceAndroidNotificationSound('alarm_clock_1'),
+      playSound: true,
+    );
+
+    final android = _plugin
+        .resolvePlatformSpecificImplementation<
+          AndroidFlutterLocalNotificationsPlugin
+        >();
+
+    await android?.createNotificationChannel(channel);
+  }
+
+  /// Android 12+ requires user approval for exact alarms
+  static Future<bool> requestExactAlarmPermission() async {
+    if (!Platform.isAndroid) return true;
+
+    final androidPlugin = _plugin
+        .resolvePlatformSpecificImplementation<
+          AndroidFlutterLocalNotificationsPlugin
+        >();
+
+    if (androidPlugin == null) return false;
+
+    final canSchedule = await androidPlugin.canScheduleExactNotifications();
+
+    if (canSchedule == true) return true;
+
+    // Opens system permission screen
+    await androidPlugin.requestExactAlarmsPermission();
+    return false;
   }
 
+  /// Schedule exact alarm (works when app is closed)
   static Future<void> scheduleAlarm({
     required int id,
     required DateTime dateTime,
@@ -32,8 +72,8 @@ class NotificationService {
       const NotificationDetails(
         android: AndroidNotificationDetails(
           'alarm_channel',
-          'Alarms',
-          channelDescription: 'Alarm notifications',
+          'Alarm Notifications',
+          channelDescription: 'Exact alarm alerts',
           importance: Importance.max,
           priority: Priority.high,
           playSound: true,
@@ -42,7 +82,6 @@ class NotificationService {
         ),
       ),
       androidScheduleMode: AndroidScheduleMode.exactAllowWhileIdle,
-      matchDateTimeComponents: DateTimeComponents.time, // ✅ NEW API
     );
   }
 

lib/core/notifications/notification_service.dart

@@ -1,13 +1,10 @@
 import 'package:flutter/material.dart';
 
-/// Centralized theme for easy scaling & branding
 class AppTheme {
-  static ThemeData get lightTheme {
-    return ThemeData(
-      useMaterial3: true,
-      colorSchemeSeed: Colors.indigo,
-      scaffoldBackgroundColor: Colors.grey.shade50,
-      appBarTheme: const AppBarTheme(centerTitle: true),
-    );
-  }
+  static ThemeData get lightTheme => ThemeData(
+    useMaterial3: true,
+    colorSchemeSeed: Colors.indigo,
+    scaffoldBackgroundColor: Colors.grey.shade50,
+    appBarTheme: const AppBarTheme(centerTitle: true),
+  );
 }

lib/core/theme/app_theme.dart

@@ -1,9 +1,32 @@
 import 'package:flutter/material.dart';
 
-/// Alarm entity model (notification-backed)
 class AlarmModel {
   final TimeOfDay time;
-  final int notificationId;
+  final int id;
+  final DateTime scheduledAt;
+  bool active;
 
-  AlarmModel({required this.time, required this.notificationId});
+  AlarmModel({
+    required this.time,
+    required this.id,
+    required this.scheduledAt,
+    this.active = true,
+  });
+
+  Map<String, dynamic> toJson() => {
+    'hour': time.hour,
+    'minute': time.minute,
+    'id': id,
+    'scheduledAt': scheduledAt.toIso8601String(),
+    'active': active,
+  };
+
+  factory AlarmModel.fromJson(Map<String, dynamic> json) {
+    return AlarmModel(
+      time: TimeOfDay(hour: json['hour'], minute: json['minute']),
+      id: json['id'],
+      scheduledAt: DateTime.parse(json['scheduledAt']),
+      active: json['active'],
+    );
+  }
 }

lib/features/Alarm/alarm_model.dart

@@ -1,6 +1,9 @@
+import 'dart:async';
 import 'package:flutter/material.dart';
-import 'alarm_model.dart';
+
 import '../../core/notifications/notification_service.dart';
+import '../../shared/storage/alarm_storage.dart';
+import 'alarm_model.dart';
 
 class AlarmScreen extends StatefulWidget {
   const AlarmScreen({super.key});
@@ -10,9 +13,52 @@ class AlarmScreen extends StatefulWidget {
 }
 
 class _AlarmScreenState extends State<AlarmScreen> {
-  final List<AlarmModel> _alarms = [];
+  final List<AlarmModel> alarms = [];
+  Timer? _ticker;
+
+  @override
+  void initState() {
+    super.initState();
+    _loadAlarms();
+    _ticker = Timer.periodic(const Duration(minutes: 1), (_) {
+      if (mounted) setState(() {});
+    });
+  }
+
+  @override
+  void dispose() {
+    _ticker?.cancel();
+    super.dispose();
+  }
+
+  Future<void> _loadAlarms() async {
+    final stored = await AlarmStorage.load();
+    if (!mounted) return;
+    alarms.addAll(stored);
+    setState(() {});
+  }
+
+  Future<void> _persist() async {
+    await AlarmStorage.save(alarms);
+  }
+
+  Duration _remainingTime(AlarmModel alarm) {
+    return alarm.scheduledAt.difference(DateTime.now());
+  }
 
   Future<void> _addAlarm() async {
+    final allowed = await NotificationService.requestExactAlarmPermission();
+    if (!allowed) {
+      if (!mounted) return;
+      ScaffoldMessenger.of(context).showSnackBar(
+        const SnackBar(
+          content: Text('Enable exact alarm permission in system settings'),
+        ),
+      );
+      return;
+    }
+
+    if (!mounted) return;
     final picked = await showTimePicker(
       context: context,
       initialTime: TimeOfDay.now(),
@@ -29,12 +75,11 @@ class _AlarmScreenState extends State<AlarmScreen> {
       picked.minute,
     );
 
-    // If selected time already passed, schedule for tomorrow
     if (scheduled.isBefore(now)) {
       scheduled = scheduled.add(const Duration(days: 1));
     }
 
-    final id = scheduled.millisecondsSinceEpoch ~/ 1000;
+    final int id = scheduled.millisecondsSinceEpoch ~/ 1000;
 
     await NotificationService.scheduleAlarm(
       id: id,
@@ -43,20 +88,38 @@ class _AlarmScreenState extends State<AlarmScreen> {
       body: 'It\'s time!',
     );
 
-    setState(() {
-      _alarms.add(AlarmModel(time: picked, notificationId: id));
+    alarms.add(
+      AlarmModel(time: picked, id: id, scheduledAt: scheduled, active: true),
+    );
 
-      _alarms.sort((a, b) {
-        final aMin = a.time.hour * 60 + a.time.minute;
-        final bMin = b.time.hour * 60 + b.time.minute;
-        return aMin.compareTo(bMin);
-      });
-    });
+    setState(() {});
+    await _persist();
+  }
+
+  Future<void> _toggleAlarm(int index, bool value) async {
+    final alarm = alarms[index];
+    alarm.active = value;
+
+    if (value) {
+      await NotificationService.scheduleAlarm(
+        id: alarm.id,
+        dateTime: alarm.scheduledAt,
+        title: '⏰ Alarm',
+        body: 'It\'s time!',
+      );
+    } else {
+      await NotificationService.cancel(alarm.id);
+    }
+
+    setState(() {});
+    await _persist();
   }
 
   Future<void> _deleteAlarm(int index) async {
-    await NotificationService.cancel(_alarms[index].notificationId);
-    setState(() => _alarms.removeAt(index));
+    await NotificationService.cancel(alarms[index].id);
+    alarms.removeAt(index);
+    setState(() {});
+    await _persist();
   }
 
   @override
@@ -67,16 +130,17 @@ class _AlarmScreenState extends State<AlarmScreen> {
         icon: const Icon(Icons.add_alarm),
         label: const Text('Add Alarm'),
       ),
-      body: _alarms.isEmpty
+      body: alarms.isEmpty
           ? const Center(child: Text('No alarms set'))
           : ListView.builder(
               padding: const EdgeInsets.all(16),
-              itemCount: _alarms.length,
+              itemCount: alarms.length,
               itemBuilder: (context, index) {
-                final alarm = _alarms[index];
+                final alarm = alarms[index];
+                final remaining = _remainingTime(alarm);
 
                 return Dismissible(
-                  key: ValueKey(alarm.notificationId),
+                  key: ValueKey(alarm.id),
                   direction: DismissDirection.endToStart,
                   onDismissed: (_) => _deleteAlarm(index),
                   background: Container(
@@ -87,7 +151,7 @@ class _AlarmScreenState extends State<AlarmScreen> {
                   ),
                   child: Card(
                     shape: RoundedRectangleBorder(
-                      borderRadius: BorderRadius.circular(15),
+                      borderRadius: BorderRadius.circular(16),
                     ),
                     child: ListTile(
                       title: Text(
@@ -97,7 +161,16 @@ class _AlarmScreenState extends State<AlarmScreen> {
                           fontWeight: FontWeight.bold,
                         ),
                       ),
-                      trailing: const Icon(Icons.notifications_active),
+                      subtitle: alarm.active && remaining.inMinutes > 0
+                          ? Text(
+                              '${remaining.inHours}h ${remaining.inMinutes % 60}m remaining',
+                              style: const TextStyle(color: Colors.grey),
+                            )
+                          : const Text('Inactive'),
+                      trailing: Switch(
+                        value: alarm.active,
+                        onChanged: (v) => _toggleAlarm(index, v),
+                      ),
                     ),
                   ),
                 );