feat: daily challenge notification service (#1632)

* feat: daily challenge notification service

* fix: replace rocket emoji

* fix: reschedule notification to the next day if today's challenge is completed

* test: add tests for daily challenge notification service

* chore: minor clean up

* fix: import order

* fix: passDailyChallenge handling

* fix: android compatibility

* fix: display android notification

---------

Co-authored-by: Niraj Nandish <[email protected]>

Author: huyenltnguyen

mobile-app/android/app/src/main/AndroidManifest.xml

@@ -4,6 +4,7 @@
     <uses-permission android:name="android.permission.WAKE_LOCK"/>
     <uses-permission android:name="android.permission.FOREGROUND_SERVICE"/>
     <uses-permission android:name="android.permission.FOREGROUND_SERVICE_MEDIA_PLAYBACK"/>
+    <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED"/>
     <application android:label="freeCodeCamp"
         android:icon="@mipmap/ic_launcher"
         android:networkSecurityConfig="@xml/network_security_config">
@@ -41,6 +42,17 @@
                 <action android:name="android.intent.action.MEDIA_BUTTON" />
             </intent-filter>
         </receiver>
+        <receiver android:exported="false"
+            android:name="com.dexterous.flutterlocalnotifications.ScheduledNotificationReceiver" />
+        <receiver android:exported="false"
+            android:name="com.dexterous.flutterlocalnotifications.ScheduledNotificationBootReceiver">
+            <intent-filter>
+                <action android:name="android.intent.action.BOOT_COMPLETED"/>
+                <action android:name="android.intent.action.MY_PACKAGE_REPLACED"/>
+                <action android:name="android.intent.action.QUICKBOOT_POWERON" />
+                <action android:name="com.htc.intent.action.QUICKBOOT_POWERON"/>
+            </intent-filter>
+        </receiver>
         <!-- Don't delete the meta-data below. This is used by the Flutter tool to generate GeneratedPluginRegistrant.java -->
         <meta-data android:name="flutterEmbedding"
             android:value="2" />

mobile-app/lib/app/app.dart

@@ -7,6 +7,7 @@ import 'package:freecodecamp/service/learn/learn_file_service.dart';
 import 'package:freecodecamp/service/learn/learn_offline_service.dart';
 import 'package:freecodecamp/service/learn/learn_service.dart';
 import 'package:freecodecamp/service/learn/daily_challenge_service.dart';
+import 'package:freecodecamp/service/learn/daily_challenge_notification_service.dart';
 import 'package:freecodecamp/service/locale_service.dart';
 import 'package:freecodecamp/service/navigation/quick_actions_service.dart';
 import 'package:freecodecamp/service/news/bookmark_service.dart';
@@ -70,6 +71,7 @@ import 'package:stacked_services/stacked_services.dart';
     LazySingleton(classType: DatabaseMigrationService),
     LazySingleton(classType: PodcastsDatabaseService),
     LazySingleton(classType: NotificationService),
+    LazySingleton(classType: DailyChallengeNotificationService),
     LazySingleton(classType: DeveloperService),
     LazySingleton(classType: AuthenticationService),
     LazySingleton(classType: AppAudioService),

mobile-app/lib/app/app.locator.dart

@@ -14,6 +14,7 @@ import 'package:freecodecamp/service/authentication/authentication_service.dart'
 import 'package:freecodecamp/service/dio_service.dart';
 import 'package:freecodecamp/service/firebase/analytics_service.dart';
 import 'package:freecodecamp/service/firebase/remote_config_service.dart';
+import 'package:freecodecamp/service/learn/daily_challenge_notification_service.dart';
 import 'package:freecodecamp/service/locale_service.dart';
 import 'package:freecodecamp/service/navigation/quick_actions_service.dart';
 import 'package:freecodecamp/service/news/api_service.dart';
@@ -50,6 +51,7 @@ Future<void> main({bool testing = false}) async {
   }
   await RemoteConfigService().init();
   await NotificationService().init();
+  await DailyChallengeNotificationService().init();
 
   runApp(const FreeCodeCampMobileApp());
 

mobile-app/lib/main.dart

@@ -0,0 +1,299 @@
+import 'dart:io';
+import 'dart:math';
+
+import 'package:flutter_local_notifications/flutter_local_notifications.dart';
+import 'package:freecodecamp/app/app.locator.dart';
+import 'package:freecodecamp/models/learn/completed_challenge_model.dart';
+import 'package:freecodecamp/models/main/user_model.dart';
+import 'package:freecodecamp/service/authentication/authentication_service.dart';
+import 'package:freecodecamp/service/learn/daily_challenge_service.dart';
+import 'package:shared_preferences/shared_preferences.dart';
+import 'package:timezone/data/latest.dart' as tz;
+import 'package:timezone/timezone.dart' as tz;
+
+class DailyChallengeNotificationService {
+  final FlutterLocalNotificationsPlugin _flutterLocalNotificationsPlugin;
+  final DailyChallengeService _dailyChallengeService;
+  final AuthenticationService _authenticationService;
+  Random random = Random();
+
+  static const String _channelId = 'daily_challenge_channel';
+  static const int _maxDays = 7;
+
+  DailyChallengeNotificationService({
+    FlutterLocalNotificationsPlugin? flutterLocalNotificationsPlugin,
+    DailyChallengeService? dailyChallengeService,
+    AuthenticationService? authenticationService,
+  })  : _flutterLocalNotificationsPlugin = flutterLocalNotificationsPlugin ??
+            FlutterLocalNotificationsPlugin(),
+        _dailyChallengeService =
+            dailyChallengeService ?? locator<DailyChallengeService>(),
+        _authenticationService =
+            authenticationService ?? locator<AuthenticationService>();
+
+  Future<void> init() async {
+    tz.initializeTimeZones();
+
+    const AndroidInitializationSettings androidInitializationSettings =
+        AndroidInitializationSettings('@mipmap/launcher_icon');
+    const DarwinInitializationSettings iosInitializationSettings =
+        DarwinInitializationSettings();
+
+    const InitializationSettings initializationSettings =
+        InitializationSettings(
+      android: androidInitializationSettings,
+      iOS: iosInitializationSettings,
+    );
+
+    await _flutterLocalNotificationsPlugin.initialize(
+      initializationSettings,
+      onDidReceiveNotificationResponse: _onNotificationResponse,
+    );
+
+    bool permissionGranted = false;
+    if (Platform.isAndroid) {
+      permissionGranted = await _flutterLocalNotificationsPlugin
+              .resolvePlatformSpecificImplementation<
+                  AndroidFlutterLocalNotificationsPlugin>()
+              ?.requestNotificationsPermission() ??
+          false;
+    } else {
+      // For iOS, we assume permission is granted after init
+      permissionGranted = true;
+    }
+
+    // Auto-enable daily notifications if system permission is granted
+    // and user hasn't explicitly disabled them
+    if (permissionGranted) {
+      final prefs = await SharedPreferences.getInstance();
+      final hasSetPreference =
+          prefs.containsKey('daily_challenge_notifications_enabled');
+
+      if (!hasSetPreference) {
+        // First time - enable notifications by default
+        await enableDailyNotifications();
+      } else if (await areNotificationsEnabled()) {
+        // Re-schedule notifications if they were previously enabled
+        await scheduleDailyChallengeNotification();
+      }
+    }
+  }
+
+  void _onNotificationResponse(NotificationResponse response) {
+    if (response.payload == 'daily_challenge_notification') {
+      // Schedule the next notification
+      scheduleDailyChallengeNotification();
+    }
+  }
+
+  Future<void> enableDailyNotifications() async {
+    final prefs = await SharedPreferences.getInstance();
+    await prefs.setBool('daily_challenge_notifications_enabled', true);
+
+    await scheduleDailyChallengeNotification();
+  }
+
+  Future<void> disableDailyNotifications() async {
+    await _flutterLocalNotificationsPlugin.cancelAll();
+    final prefs = await SharedPreferences.getInstance();
+    await prefs.setBool('daily_challenge_notifications_enabled', false);
+  }
+
+  Future<bool> areNotificationsEnabled() async {
+    final prefs = await SharedPreferences.getInstance();
+    return prefs.getBool('daily_challenge_notifications_enabled') ?? false;
+  }
+
+  Future<void> cancelAllNotifications() async {
+    await _flutterLocalNotificationsPlugin.cancelAll();
+  }
+
+  Future<bool> areSystemNotificationsEnabled() async {
+    if (Platform.isAndroid) {
+      final androidImplementation = _flutterLocalNotificationsPlugin
+          .resolvePlatformSpecificImplementation<
+              AndroidFlutterLocalNotificationsPlugin>();
+      return await androidImplementation?.areNotificationsEnabled() ?? false;
+    }
+
+    // iOS does not let apps check notification status after permission is granted, so we always return true.
+    // If campers disable notifications in iOS Settings, scheduled notifications will not be shown.
+    return true;
+  }
+
+  // This method orchestrates the scheduling of daily challenge notifications for the user.
+  // It ensures notifications are only scheduled if both user and system settings allow, and the notification window is still valid.
+  // The method determines the appropriate start date based on user progress and cached data, updates the cache,
+  // and schedules notifications for the next 7 days. If any prerequisite is not met, it exits early without scheduling.
+  Future<void> scheduleDailyChallengeNotification() async {
+    if (!(await areNotificationsEnabled()) ||
+        !(await areSystemNotificationsEnabled())) {
+      return;
+    }
+
+    // Cancel any previous scheduled notifications
+    await _flutterLocalNotificationsPlugin.cancelAll();
+
+    final prefs = await SharedPreferences.getInstance();
+    final now = DateTime.now();
+
+    // Check if notification window has expired
+    if (await hasNotificationWindowExpired(prefs, now)) {
+      return;
+    }
+
+    // Determine when to start scheduling notifications
+    final startSchedulingFrom = await determineSchedulingStartDate(prefs, now);
+    await prefs.setString('notification_schedule_start_date',
+        startSchedulingFrom.toIso8601String());
+
+    // Schedule notifications for the next 7 days
+    await scheduleNotificationsForPeriod(startSchedulingFrom, now);
+  }
+
+  Future<bool> hasNotificationWindowExpired(
+      SharedPreferences prefs, DateTime now) async {
+    final scheduleStartDateStr =
+        prefs.getString('notification_schedule_start_date');
+
+    if (scheduleStartDateStr != null) {
+      final scheduleStartDate = DateTime.parse(scheduleStartDateStr);
+      final daysSinceStart = now.difference(scheduleStartDate).inDays;
+
+      // If more than 7 days have passed and user hasn't opened the app,
+      // we assume the user has stopped engaging and stop sending them notifications.
+      return daysSinceStart >= _maxDays;
+    }
+
+    return false;
+  }
+
+  // This method determines the correct start date for scheduling notifications.
+  // If the user has completed today's challenge, returns tomorrow's date.
+  // Otherwise, returns the cached start date if available, or today if not.
+  Future<DateTime> determineSchedulingStartDate(
+      SharedPreferences prefs, DateTime now) async {
+    final scheduleStartDateStr =
+        prefs.getString('notification_schedule_start_date');
+
+    final todayChallengeCompleted = await checkIfTodayChallengeCompleted();
+    DateTime startSchedulingFrom;
+
+    if (todayChallengeCompleted) {
+      // If today's challenge is completed, start from tomorrow
+      final tomorrow = now.add(const Duration(days: 1));
+
+      startSchedulingFrom =
+          DateTime(tomorrow.year, tomorrow.month, tomorrow.day);
+    } else {
+      // If not completed, use cache if available, else today
+      if (scheduleStartDateStr != null) {
+        startSchedulingFrom = DateTime.parse(scheduleStartDateStr);
+      } else {
+        startSchedulingFrom = DateTime(now.year, now.month, now.day);
+      }
+    }
+
+    return startSchedulingFrom;
+  }
+
+  Future<bool> checkIfTodayChallengeCompleted() async {
+    try {
+      final todayChallenge = await _dailyChallengeService.fetchTodayChallenge();
+      final userModelFuture = _authenticationService.userModel;
+
+      if (userModelFuture != null) {
+        try {
+          FccUserModel user = await userModelFuture;
+          for (CompletedDailyChallenge challenge
+              in user.completedDailyCodingChallenges) {
+            if (challenge.id == todayChallenge.id) {
+              return true;
+            }
+          }
+        } catch (e) {
+          return false;
+        }
+      }
+      return false;
+    } catch (e) {
+      // If we can't fetch today's challenge, assume it's not completed
+      return false;
+    }
+  }
+
+  // This method schedules daily notifications for up to 7 days starting from the given date.
+  // For each day in the period, this method calculates the appropriate notification time and schedules a notification if the time is in the future.
+  // Notifications are set for 9 AM local time, and only future notifications are scheduled.
+  Future<void> scheduleNotificationsForPeriod(
+      DateTime startSchedulingFrom, DateTime now) async {
+    final centralLocation = tz.getLocation('America/Chicago');
+    final endDate = startSchedulingFrom.add(const Duration(days: 7));
+    int notificationId = 0;
+
+    for (DateTime date = startSchedulingFrom;
+        date.isBefore(endDate);
+        date = date.add(const Duration(days: 1))) {
+      final scheduleTime = findNextValidNotificationTime(date, centralLocation);
+
+      // Only schedule if the notification time is in the future
+      if (scheduleTime.isAfter(now)) {
+        try {
+          await _flutterLocalNotificationsPlugin.zonedSchedule(
+            notificationId++,
+            'New Daily Challenge Available! 🧩',
+            'A fresh coding challenge is waiting for you. Ready to solve it?',
+            tz.TZDateTime.from(scheduleTime, tz.local),
+            const NotificationDetails(
+              android: AndroidNotificationDetails(
+                _channelId,
+                'Daily Challenge Notifications',
+                channelDescription:
+                    'Notifications for new daily coding challenges',
+                priority: Priority.high,
+                importance: Importance.max,
+              ),
+              iOS: DarwinNotificationDetails(
+                threadIdentifier: 'daily-challenge-notification',
+                categoryIdentifier: 'DAILY_CHALLENGE',
+              ),
+            ),
+            androidScheduleMode: AndroidScheduleMode.inexact,
+            payload: 'daily_challenge_notification',
+          );
+        } catch (e) {
+          // Log the error but continue scheduling other notifications
+          print('Failed to schedule notification for $scheduleTime: $e');
+        }
+      }
+    }
+  }
+
+  DateTime findNextValidNotificationTime(
+      DateTime scheduleDate, tz.Location centralLocation,
+      {DateTime? now}) {
+    final current = now ?? DateTime.now();
+
+    // Default to 9 AM on the scheduleDate. This is used if scheduleDate is not today
+    DateTime candidate =
+        DateTime(scheduleDate.year, scheduleDate.month, scheduleDate.day, 9);
+
+    // If scheduleDate is today, adjust based on current time
+    if (scheduleDate.day == current.day &&
+        scheduleDate.month == current.month &&
+        scheduleDate.year == current.year) {
+      if (current.hour < 9) {
+        // Before 9 AM today, schedule for 9 AM today
+        candidate = DateTime(current.year, current.month, current.day, 9);
+      } else if (current.hour >= 21) {
+        // After 9 PM today, schedule for 9 AM tomorrow
+        candidate = DateTime(current.year, current.month, current.day + 1, 9);
+      } else {
+        // Between 9 AM and 9 PM, schedule for 9 AM tomorrow
+        candidate = DateTime(current.year, current.month, current.day + 1, 9);
+      }
+    }
+
+    return candidate;
+  }
+}