Problems with SensorKit data calls

The Deligate 'didFetchResult' method of fetching data past 24 hours from SensorKit is not being called. It is confirmed that you have already granted full access to the SensorKit and that data on the Ambient value in the device's personal information -> research sensor & usage data are recorded.

It is possible to export to an lz4 file. I want to have the data after 24 hours called to the app, but other Deligate methods are called, but only Deligate that gets the illumination value is not called. Is it understood that only data past 24 hours can be imported after startRecoding() is called?

If so, in order to receive data past 24 hours, do I have to continue to receive the illumination data value in the background for more than 24 hours to receive the Ambient value afterwards?

import Foundation
import SensorKit
import UIKit

final class SensorKitManager: NSObject, ObservableObject, SRSensorReaderDelegate {

    static let shared = SensorKitManager()

    private let ambientReader = SRSensorReader(sensor: .ambientLightSensor)
    
    var availableDevices: [SRDevice] = []
    @Published var ambientLightData: [AmbientLightDataPoint] = []
    
    var isFetching = false
    var isRecordingAmbientLight = false

    private override init() {
        super.init()
        setupReaders()
        checkAndRequestAuthorization()
    }

    private func setupReaders() {
        ambientReader.delegate = self
    }

    // MARK: - Permission Request
    
    func requestAuthorization() {
        SRSensorReader.requestAuthorization(sensors: [.ambientLightSensor]) { [weak self] error in
            DispatchQueue.main.async {
                guard let self = self else {
                    print("Permission request aborted")
                    return
                }
                
                if let error = error {
                    print("Permission request failed: \(error.localizedDescription)")
                } else {
                    print("Permission request succeeded")
                    self.startRecordingAmbientLightData()
                }
            }
        }
    }
    
    func checkAndRequestAuthorization() {
        let status = ambientReader.authorizationStatus
        switch status {
        case .authorized:
            print("Ambient light sensor access granted")
            startRecordingAmbientLightData()
        case .notDetermined:
            print("Ambient light sensor access undetermined, requesting permission")
            requestAuthorization()
        case .denied:
            print("Ambient light sensor access denied or restricted")
        @unknown default:
            print("Unknown authorization status")
        }
    }

    // MARK: - Ambient Light Data Logic
    
    func startRecordingAmbientLightData() {
        guard !isRecordingAmbientLight else {
            print("Already recording ambient light data.")
            return
        }
        print("Starting ambient light data recording")
        isRecordingAmbientLight = true
        ambientReader.startRecording()
        fetchAmbientLightData()
        fetchAmbientDeviceData()
    }
    
    func fetchAmbientLightData() {
        print("Fetching ambient light data")
        let request = SRFetchRequest()
        
        let now = Date()
        let fromTime = now.addingTimeInterval(-72 * 60 * 60)
        let toTime = now.addingTimeInterval(-25 * 60 * 60)

        request.from = SRAbsoluteTime(fromTime.timeIntervalSinceReferenceDate)
        request.to = SRAbsoluteTime(toTime.timeIntervalSinceReferenceDate)
        
        print("Fetch request: \(fromTime) ~ \(toTime)")
        ambientReader.fetch(request)
    }

    
    private func displayAmbientLightData(sample: SRAmbientLightSample) {
        print("Ambient light: \(sample.lux.value) lux")
        
        print("Current ambientLightData content:")
        for data in ambientLightData {
            print("Timestamp: \(data.timestamp), Lux: \(data.lux)")
        }
    }
    
    // MARK: - Device Data Logic
    
    private func fetchAmbientDeviceData() {
        print("Fetching device information")
        let request = SRFetchRequest()
        
        let now = Date()
        let fromDate = now.addingTimeInterval(-72 * 60 * 60)
        let toDate = now.addingTimeInterval(-24 * 60 * 60)
        
        request.from = SRAbsoluteTime(fromDate.timeIntervalSinceReferenceDate)
        request.to = SRAbsoluteTime(toDate.timeIntervalSinceReferenceDate)
        
        if availableDevices.isEmpty {
            print("No devices available")
            ambientReader.fetchDevices()
        } else {
            for device in availableDevices {
                print("Starting data fetch (Device: \(device))")
                request.device = device
                ambientReader.fetch(request)
                print("Fetch request sent (Device: \(device))")
            }
        }
    }
    
    // MARK: - SRSensorReaderDelegate Methods
    
    func sensorReader(_ reader: SRSensorReader, didFetch devices: [SRDevice]) {
        availableDevices = devices
        
        for device in devices {
            print("Fetched device: \(device)")
        }
        
        if !devices.isEmpty {
            fetchAmbientDeviceData()
        }
    }
    
    func sensorReader(_ reader: SRSensorReader, fetching fetchRequest: SRFetchRequest, didFetchResult result: SRFetchResult<AnyObject>) -> Bool {
        print("sensorReader(_:fetching:didFetchResult:) method called")
        
        if let ambientSample = result.sample as? SRAmbientLightSample {
            let luxValue = ambientSample.lux.value
            let timestamp = Date(timeIntervalSinceReferenceDate: result.timestamp.rawValue)
            
            // Check for duplicate data and add it
            if !ambientLightData.contains(where: { $0.timestamp == timestamp }) {
                let dataPoint = AmbientLightDataPoint(timestamp: timestamp, lux: Float(luxValue))
                ambientLightData.append(dataPoint)
                print("Added ambient light data: \(luxValue) lux, Timestamp: \(timestamp)")
            } else {
                print("Duplicate data, not adding: Timestamp: \(timestamp)")
            }
            
            // Output data
            self.displayAmbientLightData(sample: ambientSample)
        }
        
        return true
    }
    
    func sensorReader(_ reader: SRSensorReader, didCompleteFetch fetchRequest: SRFetchRequest) {
        print("Data fetch complete")
        
        if ambientLightData.isEmpty {
            print("No ambient light data within 24 hours.")
        } else {
            print("ambientLightData updated")
            for dataPoint in ambientLightData {
                print("Added ambient light data: \(dataPoint.lux) lux, Timestamp: \(dataPoint.timestamp)")
            }
        }
    }
}