SwiftUI inactivity timer

Question

I want to show a hint after the user hasn't touched a screen for 30 seconds. For this restartInactivityTimer() function needs to be called whenever the screen is touched.

Is there a way to discover any screen touch to restart the timer, but without "consuming" it's tap gesture? Do I really need to call restartInactivityTimer() from every onTapGesture (sub)view closure, like in the code snippet below?

struct MyView: View {
    @State private var inactivityTimer: Timer?

    var body: some View {
        VStack { 
            subView1
            subView2
            subView3
            subView4
        }
        .onAppear {
            restartInactivityTimer()
        }
        .onTapGesture {
            // not reaching here when any subView is touched
            restartInactivityTimer() 
        }
    }

    func restartInactivityTimer() {
        inactivityTimer?.invalidate()
        inactivityTimer = Timer.scheduledTimer(withTimeInterval: 30.0, repeats: false) { _ in
            showHint()
        }
    }

    var subView1: some View {
        // ...
        .onTapGesture {
            // ... other actions for tapping that subview
            restartInactivityTimer()
        }
    }

    // ... other subviews
}

Sweeper · Accepted Answer · 2023-09-30 12:35:08Z

4

Most solutions I see detect user activity by overriding UIApplication.sendEvent (Example). We can't do that easily in SwiftUI, but it is possible if you do method swizzling. That is quite hacky though.

You can swizzle the methods just before your app launches by writing your own entry point.

@main
struct EntryPoint {
    // swizzle here
    static func main() {
        let original = class_getInstanceMethod(UIApplication.self, #selector(UIApplication.sendEvent))!
        let new = class_getInstanceMethod(ActivityDetector.self, #selector(ActivityDetector.mySendEvent))!
        method_exchangeImplementations(original, new)

        // launch your app
        YourApp.main()
    }
    
}

struct YourApp: App {
    var body: some Scene {
        WindowGroup {
            ContentView()
        }
    }
}

The swizzled method is:

class ActivityDetector: NSObject {
    
    private typealias SendEventFunc = @convention(c) (AnyObject, Selector, UIEvent) -> Void
    
    @objc func mySendEvent(_ event: UIEvent) {
        // call the original sendEvent
        // from: https://stackoverflow.com/a/61523711/5133585
        unsafeBitCast(
            class_getMethodImplementation(ActivityDetector.self, #selector(mySendEvent)),
            to: SendEventFunc.self
        )(self, #selector(UIApplication.sendEvent), event)

        // send a notification, just like in the non-SwiftUI solutions
        NotificationCenter.default.post(name: .init("UserActivity"), object: nil)
    }
}

Now in your view, you can listen for the notification:

@State var presentAlert = false
@State var timer = Timer.publish(every: 60, on: .current, in: .common).autoconnect()

var body: some View {
    Text("Foo")
        // time is up!
        .onReceive(timer) { _ in
            presentAlert = true
            timer.upstream.connect().cancel()
        }
        // user did something!
        .onReceive(NotificationCenter.default.publisher(for: .init("UserActivity")), perform: { _ in
            timer.upstream.connect().cancel()
            timer = Timer.publish (every: 5, on: .current, in: .common).autoconnect()
        })
        .alert("Foo", isPresented: $presentAlert) {
            Button("OK") {}
        }
}

Using Timer.publish here is kind of wasteful, since you only need one output from the publisher. Consider using a Task for example:

@State var presentAlert = false
@State var task: Task<Void, Error>?

var body: some View {
    Text("Foo")
        .onAppear {
            resetTask()
        }
        .onReceive(NotificationCenter.default.publisher(for: .init("UserActivity")), perform: { _ in
            task?.cancel()
            resetTask()
        })
        .alert("Foo", isPresented: $presentAlert) {
            Button("OK") {}
        }
}

@MainActor
func resetTask() {
    task = Task {
        try await Task.sleep(for: .seconds(60))
        try Task.checkCancellation()
        presentAlert = true
    }
}

edited Sep 30, 2023 at 12:35

answered Sep 30, 2023 at 12:28

Sweeper

292k23 gold badges260 silver badges438 bronze badges

Sign up to request clarification or add additional context in comments.

3 Comments

Voyteck Over a year ago

Thank you @Sweeper for your comprehensive answer. The solution presented is more hacky and swizzling than the original solution is tiresome. I was hoping for a clever something like .onScreenActivation() modifier. Maybe it is still ahead of Apple to develop.

Sweeper Over a year ago

@Voyteck Not even the UIKit solutions have “clever something like .onScreenActiviation”. Also, “swizzling” is not an adjective here. It just means exchanging the implementations of two methods.

Martin Claesson Over a year ago

This should be the accepted answer. Using .onTapGesture will not catch all user input.

Collectives™ on Stack Overflow

SwiftUI inactivity timer

1 Answer 1

3 Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

3 Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related