The Deligate ‘didFetchResult’ technique of fetching knowledge previous 24 hours from SensorKit shouldn’t be being known as. It’s confirmed that you’ve already granted full entry to the SensorKit and that knowledge on the Ambient worth within the machine’s private data -> analysis sensor & utilization knowledge are recorded.
It’s doable to export to an lz4 file. I need to have the info after 24 hours known as to the app, however different Deligate strategies are known as, however solely Deligate that will get the illumination worth shouldn’t be known as. Is it understood that solely knowledge previous 24 hours could be imported after startRecoding() is named?
In that case, as a way to obtain knowledge previous 24 hours, do I’ve to proceed to obtain the illumination knowledge worth within the background for greater than 24 hours to obtain the Ambient worth afterwards?
import Basis
import SensorKit
import UIKit
ultimate class SensorKitManager: NSObject, ObservableObject, SRSensorReaderDelegate {
static let shared = SensorKitManager()
non-public let ambientReader = SRSensorReader(sensor: .ambientLightSensor)
var availableDevices: [SRDevice] = []
@Revealed var ambientLightData: [AmbientLightDataPoint] = []
var isFetching = false
var isRecordingAmbientLight = false
non-public override init() {
tremendous.init()
setupReaders()
checkAndRequestAuthorization()
}
non-public func setupReaders() {
ambientReader.delegate = self
}
// MARK: - Permission Request
func requestAuthorization() {
SRSensorReader.requestAuthorization(sensors: [.ambientLightSensor]) { [weak self] error in
DispatchQueue.most important.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 standing = ambientReader.authorizationStatus
change standing {
case .approved:
print("Ambient mild sensor entry granted")
startRecordingAmbientLightData()
case .notDetermined:
print("Ambient mild sensor entry undetermined, requesting permission")
requestAuthorization()
case .denied:
print("Ambient mild sensor entry denied or restricted")
@unknown default:
print("Unknown authorization standing")
}
}
// MARK: - Ambient Gentle Knowledge Logic
func startRecordingAmbientLightData() {
guard !isRecordingAmbientLight else {
print("Already recording ambient mild knowledge.")
return
}
print("Beginning ambient mild knowledge recording")
isRecordingAmbientLight = true
ambientReader.startRecording()
fetchAmbientLightData()
fetchAmbientDeviceData()
}
func fetchAmbientLightData() {
print("Fetching ambient mild knowledge")
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)
}
non-public func displayAmbientLightData(pattern: SRAmbientLightSample) {
print("Ambient mild: (pattern.lux.worth) lux")
print("Present ambientLightData content material:")
for knowledge in ambientLightData {
print("Timestamp: (knowledge.timestamp), Lux: (knowledge.lux)")
}
}
// MARK: - Gadget Knowledge Logic
non-public func fetchAmbientDeviceData() {
print("Fetching machine data")
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 units accessible")
ambientReader.fetchDevices()
} else {
for machine in availableDevices {
print("Beginning knowledge fetch (Gadget: (machine))")
request.machine = machine
ambientReader.fetch(request)
print("Fetch request despatched (Gadget: (machine))")
}
}
}
// MARK: - SRSensorReaderDelegate Strategies
func sensorReader(_ reader: SRSensorReader, didFetch units: [SRDevice]) {
availableDevices = units
for machine in units {
print("Fetched machine: (machine)")
}
if !units.isEmpty {
fetchAmbientDeviceData()
}
}
func sensorReader(_ reader: SRSensorReader, fetching fetchRequest: SRFetchRequest, didFetchResult end result: SRFetchResult) -> Bool {
print("sensorReader(_:fetching:didFetchResult:) technique known as")
if let ambientSample = end result.pattern as? SRAmbientLightSample {
let luxValue = ambientSample.lux.worth
let timestamp = Date(timeIntervalSinceReferenceDate: end result.timestamp.rawValue)
// Test for duplicate knowledge and add it
if !ambientLightData.accommodates(the place: { $0.timestamp == timestamp }) {
let dataPoint = AmbientLightDataPoint(timestamp: timestamp, lux: Float(luxValue))
ambientLightData.append(dataPoint)
print("Added ambient mild knowledge: (luxValue) lux, Timestamp: (timestamp)")
} else {
print("Duplicate knowledge, not including: Timestamp: (timestamp)")
}
// Output knowledge
self.displayAmbientLightData(pattern: ambientSample)
}
return true
}
func sensorReader(_ reader: SRSensorReader, didCompleteFetch fetchRequest: SRFetchRequest) {
print("Knowledge fetch full")
if ambientLightData.isEmpty {
print("No ambient mild knowledge inside 24 hours.")
} else {
print("ambientLightData up to date")
for dataPoint in ambientLightData {
print("Added ambient mild knowledge: (dataPoint.lux) lux, Timestamp: (dataPoint.timestamp)")
}
}
}
}
I’ve completed just about the whole lot to get the didFetchResult worth.
Whereas doing this, what I’m conscious of is that solely knowledge previous 24 hours could be fetched, and it’s judged that the strategy of didFetchResult shouldn’t be known as as a result of the info previous 24 hours shouldn’t be fetched.
I do not know why I can not get this worth when the illuminance worth is being constructed up usually day-after-day on the machine