iPhone: Wykrywanie braku aktywności / czasu bezczynności użytkownika od ostatniego dotknięcia ekranu

Czy ktoś zaimplementował funkcję, w której jeśli użytkownik nie dotyka ekranu przez określony czas, wykonujesz określoną czynność? Próbuję znaleźć najlepszy sposób na zrobienie tego.

W UIApplication jest ta nieco powiązana metoda:

[UIApplication sharedApplication].idleTimerDisabled;

Byłoby miło, gdybyś zamiast tego miał coś takiego:

NSTimeInterval timeElapsed = [UIApplication sharedApplication].idleTimeElapsed;

Następnie mógłbym ustawić licznik czasu i okresowo sprawdzać tę wartość i podejmować działania, gdy przekroczy próg.

Mam nadzieję, że to wyjaśnia, czego szukam. Czy ktoś już zajął się tym problemem lub ma jakieś przemyślenia, jak byś to zrobił? Dzięki.

Oto odpowiedź, której szukałem:

Miej podklasę delegata aplikacji UIApplication. W pliku implementacji nadpisz metodę sendEvent: w następujący sposób:

- (void)sendEvent:(UIEvent *)event {
    [super sendEvent:event];

    // Only want to reset the timer on a Began touch or an Ended touch, to reduce the number of timer resets.
    NSSet *allTouches = [event allTouches];
    if ([allTouches count] > 0) {
        // allTouches count only ever seems to be 1, so anyObject works here.
        UITouchPhase phase = ((UITouch *)[allTouches anyObject]).phase;
        if (phase == UITouchPhaseBegan || phase == UITouchPhaseEnded)
            [self resetIdleTimer];
    }
}

- (void)resetIdleTimer {
    if (idleTimer) {
        [idleTimer invalidate];
        [idleTimer release];
    }

    idleTimer = [[NSTimer scheduledTimerWithTimeInterval:maxIdleTime target:self selector:@selector(idleTimerExceeded) userInfo:nil repeats:NO] retain];
}

- (void)idleTimerExceeded {
    NSLog(@"idle time exceeded");
}

gdzie maxIdleTime i idleTimer są zmiennymi instancji.

Aby to zadziałało, musisz również zmodyfikować plik main.m tak, aby UIApplicationMain używał Twojej klasy delegata (w tym przykładzie AppDelegate) jako klasy głównej:

int retVal = UIApplicationMain(argc, argv, @"AppDelegate", @"AppDelegate");

Mam odmianę rozwiązania licznika czasu bezczynności, która nie wymaga podklasy UIApplication. Działa na określonej podklasie UIViewController, więc jest przydatny, jeśli masz tylko jeden kontroler widoku (taki jak interaktywna aplikacja lub gra) lub chcesz tylko obsłużyć limit czasu bezczynności w określonym kontrolerze widoku.

Nie odtwarza również obiektu NSTimer za każdym razem, gdy licznik czasu bezczynności jest resetowany. Tworzy nowy tylko wtedy, gdy timer odpala.

Twój kod może wywoływać resetIdleTimerinne zdarzenia, które mogą wymagać unieważnienia licznika czasu bezczynności (takie jak znaczące wejście akcelerometru).

@interface MainViewController : UIViewController
{
    NSTimer *idleTimer;
}
@end

#define kMaxIdleTimeSeconds 60.0

@implementation MainViewController

#pragma mark -
#pragma mark Handling idle timeout

- (void)resetIdleTimer {
    if (!idleTimer) {
        idleTimer = [[NSTimer scheduledTimerWithTimeInterval:kMaxIdleTimeSeconds
                                                      target:self
                                                    selector:@selector(idleTimerExceeded)
                                                    userInfo:nil
                                                     repeats:NO] retain];
    }
    else {
        if (fabs([idleTimer.fireDate timeIntervalSinceNow]) < kMaxIdleTimeSeconds-1.0) {
            [idleTimer setFireDate:[NSDate dateWithTimeIntervalSinceNow:kMaxIdleTimeSeconds]];
        }
    }
}

- (void)idleTimerExceeded {
    [idleTimer release]; idleTimer = nil;
    [self startScreenSaverOrSomethingInteresting];
    [self resetIdleTimer];
}

- (UIResponder *)nextResponder {
    [self resetIdleTimer];
    return [super nextResponder];
}

- (void)viewDidLoad {
    [super viewDidLoad];
    [self resetIdleTimer];
}

@end

(kod czyszczenia pamięci został wykluczony ze względu na zwięzłość).

Dla Swift v 3.1

nie zapomnij skomentować tej linii w AppDelegate // @ UIApplicationMain

extension NSNotification.Name {
   public static let TimeOutUserInteraction: NSNotification.Name = NSNotification.Name(rawValue: "TimeOutUserInteraction")
}


class InterractionUIApplication: UIApplication {

static let ApplicationDidTimoutNotification = "AppTimout"

// The timeout in seconds for when to fire the idle timer.
let timeoutInSeconds: TimeInterval = 15 * 60

var idleTimer: Timer?

// Listen for any touch. If the screen receives a touch, the timer is reset.
override func sendEvent(_ event: UIEvent) {
    super.sendEvent(event)

    if idleTimer != nil {
        self.resetIdleTimer()
    }

    if let touches = event.allTouches {
        for touch in touches {
            if touch.phase == UITouchPhase.began {
                self.resetIdleTimer()
            }
        }
    }
}

// Resent the timer because there was user interaction.
func resetIdleTimer() {
    if let idleTimer = idleTimer {
        idleTimer.invalidate()
    }

    idleTimer = Timer.scheduledTimer(timeInterval: timeoutInSeconds, target: self, selector: #selector(self.idleTimerExceeded), userInfo: nil, repeats: false)
}

// If the timer reaches the limit as defined in timeoutInSeconds, post this notification.
func idleTimerExceeded() {
    NotificationCenter.default.post(name:Notification.Name.TimeOutUserInteraction, object: nil)
   }
} 

utwórz plik main.swif i dodaj go (nazwa jest ważna)

CommandLine.unsafeArgv.withMemoryRebound(to: UnsafeMutablePointer<Int8>.self, capacity: Int(CommandLine.argc)) {argv in
_ = UIApplicationMain(CommandLine.argc, argv, NSStringFromClass(InterractionUIApplication.self), NSStringFromClass(AppDelegate.self))
}

Obserwowanie powiadomień w dowolnej innej klasie

NotificationCenter.default.addObserver(self, selector: #selector(someFuncitonName), name: Notification.Name.TimeOutUserInteraction, object: nil)

Ten wątek był bardzo pomocny i zawarłem go w podklasę UIWindow, która wysyła powiadomienia. Wybrałem powiadomienia, aby było to naprawdę luźne powiązanie, ale możesz łatwo dodać delegata.

Oto sedno:

http://gist.github.com/365998

Ponadto przyczyną problemu z podklasą UIApplication jest to, że NIB jest skonfigurowany do tworzenia 2 obiektów UIApplication, ponieważ zawiera aplikację i delegata. Podklasa UIWindow działa jednak świetnie.

Właściwie pomysł na podklasy działa świetnie. Po prostu nie ustawiaj delegata w UIApplicationpodklasie. Utwórz inny plik, który dziedziczy po UIApplication(np. MyApp). W IB ustaw klasę fileOwnerobiektu na, myAppaw myApp. M zaimplementuj sendEventmetodę jak powyżej. W main.m do:

int retVal = UIApplicationMain(argc,argv,@"myApp.m",@"myApp.m")

zrobione!

Właśnie napotkałem ten problem z grą, która jest kontrolowana przez ruchy, tj. Ma wyłączoną blokadę ekranu, ale powinna włączyć ją ponownie w trybie menu. Zamiast timera zawarłem wszystkie wywołania setIdleTimerDisabledw małej klasie, zapewniając następujące metody:

- (void) enableIdleTimerDelayed {
    [self performSelector:@selector (enableIdleTimer) withObject:nil afterDelay:60];
}

- (void) enableIdleTimer {
    [NSObject cancelPreviousPerformRequestsWithTarget:self];
    [[UIApplication sharedApplication] setIdleTimerDisabled:NO];
}

- (void) disableIdleTimer {
    [NSObject cancelPreviousPerformRequestsWithTarget:self];
    [[UIApplication sharedApplication] setIdleTimerDisabled:YES];
}

disableIdleTimerdezaktywuje licznik czasu bezczynności, enableIdleTimerDelayedgdy wchodzisz do menu lub cokolwiek powinno działać z aktywnym licznikiem czasu bezczynności i enableIdleTimerjest wywoływane z applicationWillResignActivemetody AppDelegate, aby zapewnić, że wszystkie zmiany zostaną poprawnie zresetowane do domyślnego zachowania systemu.
Napisałem artykuł i podałem kod pojedynczej klasy IdleTimerManager Idle Timer Handling w grach na iPhone'a

Oto inny sposób wykrywania aktywności:

Timer jest dodawany UITrackingRunLoopMode, więc może działać tylko wtedy, gdy jest UITrackingaktywność. Ma również tę zaletę, że nie spamuje Cię w przypadku wszystkich zdarzeń dotykowych, informując w ten sposób, czy w ciągu ostatnich ACTIVITY_DETECT_TIMER_RESOLUTIONsekund była aktywność . Nazwałam selektor, keepAliveponieważ wydaje się to odpowiednim przypadkiem użycia. Możesz oczywiście robić, co chcesz, z informacją, że ostatnio miała miejsce aktywność.

_touchesTimer = [NSTimer timerWithTimeInterval:ACTIVITY_DETECT_TIMER_RESOLUTION
                                        target:self
                                      selector:@selector(keepAlive)
                                      userInfo:nil
                                       repeats:YES];
[[NSRunLoop mainRunLoop] addTimer:_touchesTimer forMode:UITrackingRunLoopMode];

Ostatecznie musisz zdefiniować, co uważasz za bezczynne - czy bezczynność wynika z tego, że użytkownik nie dotyka ekranu, czy też jest to stan systemu, jeśli nie są używane żadne zasoby obliczeniowe? W wielu aplikacjach użytkownik może coś robić, nawet jeśli nie wchodzi w aktywną interakcję z urządzeniem za pośrednictwem ekranu dotykowego. Chociaż użytkownik prawdopodobnie jest zaznajomiony z koncepcją zasypiania urządzenia i zauważa, że ​​stanie się to poprzez przyciemnianie ekranu, niekoniecznie jest tak, że spodziewa się, że coś się stanie, jeśli będzie bezczynny - trzeba być ostrożnym o tym, co byś zrobił. Ale wracając do pierwotnego stwierdzenia - jeśli uznasz pierwszy przypadek za swoją definicję, nie ma naprawdę łatwego sposobu, aby to zrobić. Musisz otrzymywać każde zdarzenie dotykowe, przekazywanie go w razie potrzeby w łańcuchu odpowiedzi, jednocześnie odnotowując czas jego otrzymania. To da ci podstawę do wykonania bezczynnych obliczeń. Jeśli uważasz, że drugi przypadek jest twoją definicją, możesz grać z powiadomieniem NSPostWhenIdle, aby spróbować wykonać swoją logikę w tym czasie.

Jest sposób na zrobienie tej aplikacji bez konieczności wykonywania jakichkolwiek czynności przez poszczególne kontrolery. Po prostu dodaj rozpoznawanie gestów, który nie anuluje dotknięć. W ten sposób wszystkie dotknięcia będą śledzone dla timera, a inne dotknięcia i gesty w ogóle nie będą miały wpływu, więc nikt inny nie musi o tym wiedzieć.

fileprivate var timer ... //timer logic here

@objc public class CatchAllGesture : UIGestureRecognizer {
    override public func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent) {
        super.touchesBegan(touches, with: event)
    }
    override public func touchesEnded(_ touches: Set<UITouch>, with event: UIEvent) {
        //reset your timer here
        state = .failed
        super.touchesEnded(touches, with: event)
    }
    override public func touchesMoved(_ touches: Set<UITouch>, with event: UIEvent) {
        super.touchesMoved(touches, with: event)
    }
}

@objc extension YOURAPPAppDelegate {

    func addGesture () {
        let aGesture = CatchAllGesture(target: nil, action: nil)
        aGesture.cancelsTouchesInView = false
        self.window.addGestureRecognizer(aGesture)
    }
}

W przypadku, gdy delegat aplikacji zakończył metodę uruchamiania, po prostu wywołaj addGesture i gotowe. Wszystkie dotknięcia przechodzą przez metody CatchAllGesture bez przeszkadzania w działaniu innych.