[Technical Questions] Run background notifications

[elsa-bismuth]

In what area do you have a technical challenge?

Xcode, Simulator & Previews

Description

Hi!
I am trying to send notifications every 5 hours starting at 8am. However, I want the notifications to be sent even if the app is not opened, and run in the background. I want that every 5h, if they haven't reached their goal of 60min of activity this day, it sends a reminder.

Problem: Thread error.

Reproduction

In my ActivityManager.swift file:

    func sendActivityReminder() {
        UNUserNotificationCenter.current().removePendingNotificationRequests(withIdentifiers: ["activityReminder"])
        
        let today = Date()
        let totalActiveMinutes = activities
            .filter { Calendar.current.isDate($0.date, inSameDayAs: today) }
            .reduce(0) { $0 + $1.activeMinutes }
        
        let content = UNMutableNotificationContent()
        content.title = "🏃 Keep Moving!"
        
        if totalActiveMinutes >= 60 {
            content.body = "🎉 Amazing! You've reached your daily goal of 60 minutes! Keep up the great work!"
        } else {
            let remainingMinutes = 60 - totalActiveMinutes
            content.body = "You're only \(remainingMinutes) minutes away from your daily goal! Keep going! 🚀"
            
            let request = UNNotificationRequest(identifier: "activityReminder", content: content, trigger: nil)
            
            UNUserNotificationCenter.current().add(request)
        }
    }

In the Stanford360Delegate.swift:

// This source file is part of the Stanford 360 based on the Stanford Spezi Template Application project
//
// SPDX-FileCopyrightText: 2025 Stanford University
//
// SPDX-License-Identifier: MIT
//
import BackgroundTasks
import class FirebaseFirestore.FirestoreSettings
import class FirebaseFirestore.MemoryCacheSettings
import Spezi
import SpeziAccount
import SpeziFirebaseAccount
import SpeziFirebaseAccountStorage
import SpeziFirebaseStorage
import SpeziFirestore
import SpeziHealthKit
import SpeziNotifications
import SpeziOnboarding
import SpeziScheduler
import SwiftUI
import UserNotifications


class Stanford360Delegate: SpeziAppDelegate {
    let activityReminderTaskId = "com.stanford360.activityReminder"
    let sharedActivityManager = ActivityManager()
    
    override var configuration: Configuration {
        Configuration(standard: Stanford360Standard()) {
            if !FeatureFlags.disableFirebase {
                AccountConfiguration(
                    service: FirebaseAccountService(providers: [.emailAndPassword, .signInWithApple], emulatorSettings: accountEmulator),
                    storageProvider: FirestoreAccountStorage(storeIn: FirebaseConfiguration.userCollection),
                    configuration: [
                        .requires(\.userId),
                        .requires(\.name),

                        // additional values stored using the `FirestoreAccountStorage` within our Standard implementation
                        .collects(\.genderIdentity),
                        .collects(\.dateOfBirth)
                    ]
                )

                firestore
                if FeatureFlags.useFirebaseEmulator {
                    FirebaseStorageConfiguration(emulatorSettings: (host: "localhost", port: 9199))
                } else {
                    FirebaseStorageConfiguration()
                }
            }

            if HKHealthStore.isHealthDataAvailable() {
                healthKit
            }
            
            Stanford360Scheduler()
            Scheduler()
            OnboardingDataSource()

            Notifications()
        }
    }
    
    private var accountEmulator: (host: String, port: Int)? {
        if FeatureFlags.useFirebaseEmulator {
            (host: "localhost", port: 9099)
        } else {
            nil
        }
    }
    
    private var firestore: Firestore {
        let settings = FirestoreSettings()
        if FeatureFlags.useFirebaseEmulator {
            settings.host = "localhost:8080"
            settings.cacheSettings = MemoryCacheSettings()
            settings.isSSLEnabled = false
        }
        
        return Firestore(
            settings: settings
        )
    }
    
    
    private var healthKit: HealthKit {
        HealthKit {
            CollectSample(
                HKQuantityType(.stepCount),
                deliverySetting: .anchorQuery(.automatic)
            )
            CollectSample(
                HKQuantityType(.distanceWalkingRunning),
                deliverySetting: .anchorQuery(.automatic)
            )
            CollectSample(
                HKQuantityType(.activeEnergyBurned),
                deliverySetting: .anchorQuery(.automatic)
            )
        }
    }
    
    override func application(
        _ application: UIApplication,
        willFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]? = [:]
    ) -> Bool {
        registerBackgroundTask()
        scheduleBackgroundActivityReminder()
        if !UserDefaults.standard.bool(forKey: "hasAskedForNotificationPermission") {
            requestNotificationPermission()
        }
        return true
    }

    /// Registers the background task
    private func registerBackgroundTask() {
        BGTaskScheduler.shared.register(
            forTaskWithIdentifier: activityReminderTaskId,
            using: nil
        ) { task in
            if let task = task as? BGAppRefreshTask {
                self.handleBackgroundActivityReminder(
                    task: task,
                    activityManager: self.sharedActivityManager
                )
            }
        }
    }

    /// Schedules the background task to start at 8 AM and repeat every 5 hours
    func scheduleBackgroundActivityReminder() {
        let request = BGAppRefreshTaskRequest(identifier: activityReminderTaskId)
        
        guard let baseDate = Calendar.current.date(
            bySettingHour: 8,
            minute: 0,
            second: 0,
            of: Date()
        ) else {
            print("Failed to compute base date for scheduling.")
            return
        }
        let nextRun = baseDate.addingTimeInterval(5 * 60 * 60) // 8 AM first, then run every 5 hours
        request.earliestBeginDate = nextRun

        do {
            try BGTaskScheduler.shared.submit(request)
            if let earliestDate = request.earliestBeginDate {
                print("Scheduled background activity reminder at \(earliestDate)")
            } else {
                print("Failed to retrieve earliest begin date.")
            }
        } catch {
            print("Failed to schedule activity reminder: \(error.localizedDescription)")
        }
    }

    /// Handles the background task execution
    func handleBackgroundActivityReminder(task: BGAppRefreshTask, activityManager: ActivityManager) {
        activityManager.sendActivityReminder()
        task.setTaskCompleted(success: true)
        scheduleBackgroundActivityReminder() // Reschedule for continuous monitoring
    }


    /// Requests notification permissions
    private func requestNotificationPermission() {
        let center = UNUserNotificationCenter.current()
        center.getNotificationSettings { settings in
            guard settings.authorizationStatus == .notDetermined else {
                return
            }
            
            center.requestAuthorization(options: [.alert, .sound, .badge]) { granted, error in
                if granted {
                    print("Notification permission granted!")
                    UserDefaults.standard.set(true, forKey: "hasAskedForNotificationPermission")
                } else if let error = error {
                    print("Failed to request notification permission: \(error)")
                }
            }
        }
    }
}

I also added in the info file:

    <array>
        <string>com.stanford360.activityReminder</string>
    </array>

and added the necessary capabilities in background mode.

I get the error:
"Failed to schedule activity reminder: The operation could not be completed. (BGTaskSchedulerErrorDomain error 1.)"

How can I solve this?

Expected behavior

I am trying to send notifications every 5 hours starting at 8am. However, I want the notifications to be sent even if the app is not opened, and run in the background. I want that every 5h, if they haven't reached their goal of 60min of activity this day, it sends a reminder.

Additional context

No response

Code of Conduct

• I agree to follow this course's Code of Conduct and Contributing Guidelines

[nriedman]

Hi @elsa-bismuth!

It looks like the current implementation works directly with BGAppRefreshTaskRequest and the "manual" local notification system. Instead, it will be much easier to use the SpeziScheduler module. This will allow you to easily define recurring Tasks and provide code blocks that check if the Task has been completed. Please look through the documentation provided at the link, which has coding examples and thorough explanations of the different components of the library. In particular, you might find SchedulerNotifications to be particularly helpful.

Finally, for an example, see the Spezi Template Application, which includes a fully implemented local notification system (see Scheduler).

Please feel free to come to office hours with specific questions regarding how to use SpeziScheduler!