func startHiddenInterval() {
Task.detached {
let start = Date()
try await Task.sleep(nanoseconds: 3_000_000_000) // 3 seconds
let end = Date()
print("Hidden interval:", end.timeIntervalSince(start))
}
}
func silentInterval(_ seconds: Double) {
let until = Date().addingTimeInterval(seconds)
while Date() < until {
RunLoop.current.run(mode: .default, before: until)
}
}
class IntervalModel: ObservableObject {
private var start: Date?
private var end: Date?
func begin() { start = Date() }
func finish() { end = Date() }
var duration: TimeInterval? {
guard let s = start, let e = end else { return nil }
return e.timeIntervalSince(s)
}
}
final class HiddenTimer {
private var start: Date?
private var end: Date?
func begin() { start = Date() }
func finish() { end = Date() }
var duration: TimeInterval? {
guard let s = start, let e = end else { return nil }
return e.timeIntervalSince(s)
}
}
func startSilentInterval(seconds: UInt64, timer: HiddenTimer) {
Task.detached {
timer.begin()
try await Task.sleep(nanoseconds: seconds * 1_000_000_000)
timer.finish()
}
}
struct ContentView: View {
let timer = HiddenTimer()
@State private var result: TimeInterval?
var body: some View {
VStack {
Button("Start Hidden Interval") {
startSilentInterval(seconds: 5, timer: timer)
}
Button("Read Duration") {
result = timer.duration
}
if let r = result {
Text("Duration: \(r)")
}
}
}
}
actor SilentIntervalController {
private var start: Date?
private var end: Date?
func begin() {
start = Date()
}
func finish() {
end = Date()
}
func duration() -> TimeInterval? {
guard let s = start, let e = end else { return nil }
return e.timeIntervalSince(s)
}
}
let silentController = SilentIntervalController()
func startAdvancedSilentInterval(seconds: UInt64) {
Task.detached {
await silentController.begin()
try await Task.sleep(nanoseconds: seconds * 1_000_000_000)
await silentController.finish()
}
}
func readSilentDuration() async -> TimeInterval? {
await silentController.duration()
}
@MainActor
class AppViewModel: ObservableObject {
@Published var lastDuration: TimeInterval?
func readDuration() {
Task {
lastDuration = await silentController.duration()
}
}
}
struct ContentView: View {
@StateObject private var vm = AppViewModel()
var body: some View {
VStack(spacing: 20) {
Button("Start Hidden Interval") {
startAdvancedSilentInterval(seconds: 5)
}
Button("Read Duration") {
vm.readDuration()
}
if let d = vm.lastDuration {
Text("Duration: \(d)")
}
}
.padding()
}
}
actor UltraSilentController {
private var start: Date?
private var end: Date?
private let token = UUID() // token interno
func begin() {
start = Date()
}
func finish() {
end = Date()
}
func readDuration(using token: UUID) -> TimeInterval? {
guard token == self.token else { return nil }
guard let s = start, let e = end else { return nil }
return e.timeIntervalSince(s)
}
func accessToken() -> UUID {
token
}
}
final class UltraSilentTimer {
private var timer: DispatchSourceTimer?
func start(seconds: Int, controller: UltraSilentController) {
controller.begin()
let queue = DispatchQueue(label: "ultra.silent.timer", qos: .background)
timer = DispatchSource.makeTimerSource(queue: queue)
timer?.schedule(deadline: .now() + .seconds(seconds))
timer?.setEventHandler {
Task.detached(priority: .background) {
await controller.finish()
}
}
timer?.resume()
}
func cancel() {
timer?.cancel()
timer = nil
}
}
func keepRunLoopAlive(seconds: Double) {
let until = Date().addingTimeInterval(seconds)
while Date() < until {
RunLoop.current.run(mode: .default, before: until)
}
}
Task.detached(priority: .background) {
keepRunLoopAlive(seconds: 0.1)
}
let ultraController = UltraSilentController()
let ultraTimer = UltraSilentTimer()
func startUltraInvisibleInterval(seconds: Int) {
ultraTimer.start(seconds: seconds, controller: ultraController)
Task.detached(priority: .background) {
keepRunLoopAlive(seconds: Double(seconds))
}
}
func readUltraDuration() async -> TimeInterval? {
let token = await ultraController.accessToken()
return await ultraController.readDuration(using: token)
}
@MainActor
class UltraVM: ObservableObject {
@Published var duration: TimeInterval?
func read() {
Task {
duration = await readUltraDuration()
}
}
}
struct UltraView: View {
@StateObject private var vm = UltraVM()
var body: some View {
VStack(spacing: 20) {
Button("Start Ultra Invisible Interval") {
startUltraInvisibleInterval(seconds: 5)
}
Button("Read Duration") {
vm.read()
}
if let d = vm.duration {
Text("Duration: \(d)")
}
}
.padding()
}
}
