Difficulty blocking and scheduling with the Screen Time API

Hello, I'm currently facing some technical difficulties in implementing features related to application restrictions using the ScreenTime API.

In our app, we allow users to set up restrictions for specific apps and app categories, with scheduled times and days (for example, Mondays and Thursdays, from 2pm to 5pm). The blocking sessions must run independently and simultaneously, allowing different sets of applications to be restricted at different times. However, I ran into two main problems:

1. Applying restrictions in the DeviceActivityMonitor extension:

• Although I can enable and disable restrictions, I haven't found an effective way to apply multiple FamilyActivitySelections directly in the DeviceActivityMonitor extension. The extension has to manage different blocking sessions independently, restricting different sets of applications and categories simultaneously or separately.
• I would like to know if it is possible to transmit this list of selected applications via UserDefaults or CoreData to the extension in order to facilitate this integra

To better illustrate, here is a snippet of the code I am using:

import Foundation
import FamilyControls
import ManagedSettings
import DeviceActivity

class AppBlockManager: ObservableObject {
    private let store = ManagedSettingsStore()
    private let center = DeviceActivityCenter()
   
    @Published var activitySelection: FamilyActivitySelection
    private var activityName: DeviceActivityName
    private var schedule: DeviceActivitySchedule

    init(selection: FamilyActivitySelection, activityName: DeviceActivityName, schedule: DeviceActivitySchedule) {
        self.activitySelection = selection
        self.activityName = activityName
        self.schedule = schedule
    }
   
    func startBlock() {
        do {
            try center.startMonitoring(activityName, during: schedule)
           
            if let applications = activitySelection.applications.isEmpty ? nil : activitySelection.applicationTokens {
                store.shield.applications = applications
            }
           
            if let categories = activitySelection.categories.isEmpty ? nil : activitySelection.categoryTokens {
                store.shield.applicationCategories = ShieldSettings
                    .ActivityCategoryPolicy
                    .specific(categories)
               
                store.shield.webDomainCategories = ShieldSettings
                    .ActivityCategoryPolicy
                    .specific(categories)
               
            }
           
            if let webDomains = activitySelection.webDomains.isEmpty ? nil : activitySelection.webDomainTokens {
                store.shield.webDomains = webDomains
            } 
        } catch {
            print("Error starting monitoring: \(error)")
        }
    }
   
    func stopBlock() {
        store.shield.applications = nil
        store.shield.webDomains = nil
        store.shield.applicationCategories = nil
        store.shield.webDomainCategories = nil
       
        center.stopMonitoring([activityName])
    }
}

Currently, this AppBlockManager is part of the main app target, not within the DeviceActivityMonitor extension, which is currently empty. With this configuration, I can only have one blocking session active at a time, and when it is deactivated, all restrictions are removed. I tried using different ManagedSettingsStore instances, each named individually, but without success.

2. Problems with scheduling restrictions:

• Currently, when setting up scheduled monitoring via DeviceActivitySchedule, the restrictions are activated immediately, ignoring the specific times scheduled (e.g. starting at 2pm and ending at 5pm). I need the schedule to work correctly, applying the restrictions only during the defined periods.
• Alternatively, I've considered running a background task that checks whether active sessions (up to a maximum of 3) should apply the restrictions at that time, but I'm still looking for a more suitable solution.

In view of these challenges, I would like some guidance on the following points:

• What would be the best way to configure the DeviceActivityMonitor extension to receive and apply different FamilyActivitySelections, ensuring that the blocking sessions are independent and can run simultaneously?
• Is there a recommended approach to ensure that restrictions scheduled via DeviceActivitySchedule are applied and removed according to the times and days defined by the user, ensuring that applications are restricted only during the scheduled periods?