iPhone: detección de inactividad del usuario / tiempo de inactividad desde la última pantalla táctil

¿Alguien ha implementado una función en la que si el usuario no ha tocado la pantalla durante un cierto período de tiempo, usted toma una determinada acción? Estoy tratando de encontrar la mejor manera de hacerlo.

Existe este método algo relacionado en UIApplication:

[UIApplication sharedApplication].idleTimerDisabled;

Sería bueno si tuvieras algo como esto:

NSTimeInterval timeElapsed = [UIApplication sharedApplication].idleTimeElapsed;

Entonces podría configurar un temporizador y verificar periódicamente este valor, y tomar alguna acción cuando exceda un umbral.

Espero que eso explique lo que estoy buscando. ¿Alguien ha abordado este problema o tiene alguna idea sobre cómo lo haría? Gracias.

Aquí está la respuesta que había estado buscando:

Haga que su aplicación delegue la subclase UIApplication. En el archivo de implementación, anule el método sendEvent: así:

- (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");
}

donde maxIdleTime e idleTimer son variables de instancia.

Para que esto funcione, también debe modificar su main.m para decirle a UIApplicationMain que use su clase delegada (en este ejemplo, AppDelegate) como la clase principal:

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

Tengo una variación de la solución de temporizador inactivo que no requiere subclasificar la aplicación UIA. Funciona en una subclase específica de UIViewController, por lo que es útil si solo tiene un controlador de vista (como puede tener una aplicación o juego interactivo) o si solo desea manejar el tiempo de espera inactivo en un controlador de vista específico.

Tampoco vuelve a crear el objeto NSTimer cada vez que se reinicia el temporizador inactivo. Solo crea uno nuevo si se dispara el temporizador.

Su código puede llamar resetIdleTimera cualquier otro evento que pueda necesitar invalidar el temporizador inactivo (como una entrada significativa del acelerómetro).

@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

(código de limpieza de memoria excluido por brevedad).

Para swift v 3.1

no olvides comentar esta línea en 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)
   }
} 

cree el archivo main.swif y agregue esto (el nombre es importante)

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

Observación de notificaciones en cualquier otra clase

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

Este hilo fue de gran ayuda, y lo envolví en una subclase de UIWindow que envía notificaciones. Elegí notificaciones para que sea un acoplamiento realmente flojo, pero puedes agregar un delegado con bastante facilidad.

Aquí está la esencia:

http://gist.github.com/365998

Además, la razón del problema de la subclase UIApplication es que la NIB está configurada para luego crear 2 objetos UIApplication ya que contiene la aplicación y el delegado. Sin embargo, la subclase UIWindow funciona muy bien.

En realidad, la idea de subclases funciona muy bien. Simplemente no hagas que tu delegado sea la UIApplicationsubclase. Cree otro archivo que herede de UIApplication(por ejemplo, myApp). En IB, establezca la clase del fileOwnerobjeto en myAppy en myApp.m implemente el sendEventmétodo como se indica arriba. En main.m do:

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

et voilà!

Acabo de encontrarme con este problema con un juego que está controlado por movimientos, es decir, tiene el bloqueo de pantalla deshabilitado pero debería habilitarlo nuevamente cuando esté en el modo de menú. En lugar de un temporizador, encapsulé todas las llamadas setIdleTimerDisableddentro de una clase pequeña proporcionando los siguientes métodos:

- (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];
}

disableIdleTimerdesactiva el temporizador inactivo, enableIdleTimerDelayedal ingresar al menú o lo que sea que se ejecute con el temporizador inactivo activo y enableIdleTimerse llama desde el applicationWillResignActivemétodo de AppDelegate para garantizar que todos los cambios se restablezcan correctamente al comportamiento predeterminado del sistema.
Escribí un artículo y proporcioné el código para la clase de singleton IdleTimerManager Idle Timer Handling en juegos de iPhone

Aquí hay otra forma de detectar actividad:

Se agrega el temporizador UITrackingRunLoopMode, por lo que solo puede disparar si hay UITrackingactividad. También tiene la ventaja de no enviarle correos no deseados para todos los eventos táctiles, informando así si hubo actividad en los últimos ACTIVITY_DETECT_TIMER_RESOLUTIONsegundos. Llamé al selector keepAliveya que parece un caso de uso apropiado para esto. Por supuesto, puede hacer lo que desee con la información de que hubo actividad recientemente.

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

En última instancia, debe definir lo que considera inactivo: ¿está inactivo el resultado de que el usuario no toca la pantalla o es el estado del sistema si no se utilizan recursos informáticos? Es posible, en muchas aplicaciones, que el usuario haga algo incluso si no interactúa activamente con el dispositivo a través de la pantalla táctil. Si bien el usuario probablemente esté familiarizado con el concepto de que el dispositivo se va a dormir y el aviso de que sucederá a través de la atenuación de la pantalla, no es necesariamente el caso de que esperen que ocurra algo si están inactivos; debe tener cuidado sobre lo que harías Pero volviendo a la declaración original: si considera que el primer caso es su definición, no hay una manera realmente fácil de hacerlo. Debería recibir cada evento táctil, pasarlo a lo largo de la cadena de respuesta según sea necesario, al tiempo que señala la hora en que se recibió. Eso le dará alguna base para hacer el cálculo inactivo. Si considera que el segundo caso es su definición, puede jugar con una notificación NSPostWhenIdle para intentar realizar su lógica en ese momento.

Hay una manera de hacer esta aplicación de manera amplia sin que los controladores individuales tengan que hacer nada. Simplemente agregue un reconocedor de gestos que no cancele toques. De esta manera, todos los toques se rastrearán para el temporizador, y otros toques y gestos no se verán afectados en absoluto, por lo que nadie más tiene que saberlo.

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)
    }
}

En el delegado de su aplicación, terminó el método de inicio, simplemente llame a addGesture y ya está todo listo. Todos los toques pasarán por los métodos de CatchAllGesture sin que esto impida la funcionalidad de otros.