iPhone: détection de l'inactivité / du temps d'inactivité de l'utilisateur depuis la dernière touche d'écran

Quelqu'un a-t-il implémenté une fonctionnalité où si l'utilisateur n'a pas touché l'écran pendant une certaine période, vous prenez une certaine action? J'essaie de trouver la meilleure façon de le faire.

Il y a cette méthode quelque peu liée dans UIApplication:

[UIApplication sharedApplication].idleTimerDisabled;

Ce serait bien si vous aviez quelque chose comme ça à la place:

NSTimeInterval timeElapsed = [UIApplication sharedApplication].idleTimeElapsed;

Ensuite, je pourrais configurer une minuterie et vérifier périodiquement cette valeur, et prendre des mesures lorsqu'elle dépasse un seuil.

J'espère que cela explique ce que je recherche. Quelqu'un a-t-il déjà abordé ce problème ou a-t-il des idées sur la façon dont vous le feriez? Merci.

Voici la réponse que je cherchais:

Demandez à votre délégué d'application de sous-classe UIApplication. Dans le fichier d'implémentation, remplacez la méthode sendEvent: comme suit:

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

où maxIdleTime et idleTimer sont des variables d'instance.

Pour que cela fonctionne, vous devez également modifier votre main.m pour indiquer à UIApplicationMain d'utiliser votre classe de délégué (dans cet exemple, AppDelegate) comme classe principale:

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

J'ai une variante de la solution de minuterie d'inactivité qui ne nécessite pas de sous-classement UIApplication. Il fonctionne sur une sous-classe UIViewController spécifique, il est donc utile si vous n'avez qu'un seul contrôleur de vue (comme une application ou un jeu interactif peut avoir) ou si vous souhaitez uniquement gérer le délai d'inactivité dans un contrôleur de vue spécifique.

Il ne recrée pas non plus l'objet NSTimer chaque fois que le minuteur d'inactivité est réinitialisé. Il n'en crée un nouveau que si la minuterie se déclenche.

Votre code peut appeler resetIdleTimerpour tout autre événement qui peut nécessiter d'invalider la minuterie d'inactivité (comme une entrée d'accéléromètre importante).

@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

(code de nettoyage de la mémoire exclu par souci de concision.)

Pour swift v 3.1

n'oubliez pas de commenter cette ligne dans 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)
   }
} 

créez le fichier main.swif et ajoutez-le (le nom est important)

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

Observer la notification dans une autre classe

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

Ce fil a été d'une grande aide, et je l'ai encapsulé dans une sous-classe UIWindow qui envoie des notifications. J'ai choisi les notifications pour en faire un véritable couplage lâche, mais vous pouvez ajouter un délégué assez facilement.

Voici l'essentiel:

http://gist.github.com/365998

En outre, la raison du problème de sous-classe UIApplication est que le NIB est configuré pour créer ensuite 2 objets UIApplication car il contient l'application et le délégué. La sous-classe UIWindow fonctionne très bien cependant.

En fait, l'idée de sous-classification fonctionne très bien. Ne faites pas de votre délégué la UIApplicationsous - classe. Créez un autre fichier qui hérite de UIApplication(par exemple myApp). Dans IB, définissez la classe de l' fileOwnerobjet sur myAppet dans myApp.m implémentez la sendEventméthode comme ci-dessus. Dans main.m faire:

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

et voilà!

Je viens de rencontrer ce problème avec un jeu qui est contrôlé par des mouvements, c'est-à-dire que le verrouillage de l'écran est désactivé mais devrait le réactiver en mode menu. Au lieu d'un minuteur, j'ai encapsulé tous les appels setIdleTimerDisableddans une petite classe fournissant les méthodes suivantes:

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

disableIdleTimerdésactive la minuterie d'inactivité, enableIdleTimerDelayedlorsque vous entrez dans le menu ou tout ce qui devrait fonctionner avec la minuterie d'inactivité active et enableIdleTimerest appelée à partir de la applicationWillResignActiveméthode de votre AppDelegate pour garantir que toutes vos modifications sont correctement réinitialisées au comportement par défaut du système.
J'ai écrit un article et fourni le code de la classe singleton IdleTimerManager Idle Timer Handling in iPhone Games

Voici une autre façon de détecter l'activité:

Le minuteur est ajouté UITrackingRunLoopMode, de sorte qu'il ne peut se déclencher qu'en cas d' UITrackingactivité. Il a également l'avantage de ne pas vous envoyer de spam pour tous les événements tactiles, vous informant ainsi s'il y a eu une activité dans les dernières ACTIVITY_DETECT_TIMER_RESOLUTIONsecondes. J'ai nommé le sélecteur keepAlivecar il semble être un cas d'utilisation approprié pour cela. Vous pouvez bien sûr faire ce que vous désirez avec l'information selon laquelle il y a eu une activité récemment.

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

En fin de compte, vous devez définir ce que vous considérez comme inactif: l'inactivité est-elle le résultat du fait que l'utilisateur ne touche pas l'écran ou est-ce l'état du système si aucune ressource informatique n'est utilisée? Il est possible, dans de nombreuses applications, que l'utilisateur fasse quelque chose même s'il n'interagit pas activement avec l'appareil via l'écran tactile. Bien que l'utilisateur soit probablement familier avec le concept de mise en veille de l'appareil et la notification que cela se produira via la gradation de l'écran, il n'est pas nécessairement le cas qu'il s'attend à ce que quelque chose se passe s'il est inactif - vous devez être prudent sur ce que vous feriez. Mais revenons à la déclaration originale - si vous considérez que le premier cas est votre définition, il n'y a pas de moyen vraiment facile de le faire. Vous auriez besoin de recevoir chaque événement tactile, le transmettre sur la chaîne de répondeurs au besoin tout en notant l'heure à laquelle il a été reçu. Cela vous donnera une base pour faire le calcul inactif. Si vous considérez que le deuxième cas est votre définition, vous pouvez jouer avec une notification NSPostWhenIdle pour essayer d'exécuter votre logique à ce moment-là.

Il existe un moyen de faire cette application à l'échelle sans que les contrôleurs individuels aient à faire quoi que ce soit. Ajoutez simplement un outil de reconnaissance de gestes qui n'annule pas les touches. De cette façon, toutes les touches seront suivies pour le chronomètre, et les autres touches et gestes ne seront pas du tout affectés, donc personne d'autre n'a à le savoir.

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

Dans la méthode de lancement de la fin de votre délégué d'application, appelez simplement addGesture et vous êtes prêt. Toutes les touches passeront par les méthodes de CatchAllGesture sans que cela empêche la fonctionnalité des autres.