Existe-t-il un moyen de détecter si une fenêtre de navigateur n'est pas actuellement active?

J'ai JavaScript qui fait régulièrement de l'activité. Lorsque l'utilisateur ne regarde pas le site (c'est-à-dire que la fenêtre ou l'onglet n'a pas le focus), ce serait bien de ne pas s'exécuter.

Existe-t-il un moyen de le faire en utilisant JavaScript?

Mon point de référence: Gmail Chat émet un son si la fenêtre que vous utilisez n'est pas active.

Depuis la rédaction initiale de cette réponse, une nouvelle spécification a atteint le statut de recommandation grâce au W3C. L' API de visibilité des pages (sur MDN ) nous permet désormais de détecter plus précisément lorsqu'une page est masquée pour l'utilisateur.

document.addEventListener("visibilitychange", onchange);

Prise en charge actuelle du navigateur:

• Chrome 13+
• Internet Explorer 10+
• Firefox 10+
• Opera 12.10+ ^{[ lire les notes ]}

Le code suivant revient à la méthode de flou / focus moins fiable dans les navigateurs incompatibles:

(function() {
  var hidden = "hidden";

  // Standards:
  if (hidden in document)
    document.addEventListener("visibilitychange", onchange);
  else if ((hidden = "mozHidden") in document)
    document.addEventListener("mozvisibilitychange", onchange);
  else if ((hidden = "webkitHidden") in document)
    document.addEventListener("webkitvisibilitychange", onchange);
  else if ((hidden = "msHidden") in document)
    document.addEventListener("msvisibilitychange", onchange);
  // IE 9 and lower:
  else if ("onfocusin" in document)
    document.onfocusin = document.onfocusout = onchange;
  // All others:
  else
    window.onpageshow = window.onpagehide
    = window.onfocus = window.onblur = onchange;

  function onchange (evt) {
    var v = "visible", h = "hidden",
        evtMap = {
          focus:v, focusin:v, pageshow:v, blur:h, focusout:h, pagehide:h
        };

    evt = evt || window.event;
    if (evt.type in evtMap)
      document.body.className = evtMap[evt.type];
    else
      document.body.className = this[hidden] ? "hidden" : "visible";
  }

  // set the initial state (but only if browser supports the Page Visibility API)
  if( document[hidden] !== undefined )
    onchange({type: document[hidden] ? "blur" : "focus"});
})();

onfocusinet onfocusoutsont requis pour IE 9 et inférieur , tandis que tous les autres utilisent onfocuset onblur, à l'exception d'iOS, qui utilise onpageshowet onpagehide.

J'utiliserais jQuery car alors tout ce que vous avez à faire est le suivant:

$(window).blur(function(){
  //your code here
});
$(window).focus(function(){
  //your code
});

Ou du moins, cela a fonctionné pour moi.

Il existe 3 méthodes typiques utilisées pour déterminer si l'utilisateur peut voir la page HTML, mais aucune ne fonctionne parfaitement:

• L' API de visibilité de page du W3C est censée faire cela (prise en charge depuis: Firefox 10, MSIE 10, Chrome 13). Cependant, cette API ne déclenche des événements que lorsque l'onglet du navigateur est entièrement remplacé (par exemple lorsque l'utilisateur passe d'un onglet à un autre). L'API ne déclenche pas d'événements lorsque la visibilité ne peut pas être déterminée avec une précision de 100% (par exemple Alt + Tab pour passer à une autre application).

• L'utilisation de méthodes basées sur le focus / flou vous donne beaucoup de faux positifs. Par exemple, si l'utilisateur affiche une fenêtre plus petite en haut de la fenêtre du navigateur, la fenêtre du navigateur perdra le focus ( onblursurélevée) mais l'utilisateur est toujours en mesure de la voir (il doit donc être actualisé). Voir aussi http://javascript.info/tutorial/focus

• S'appuyer sur l'activité de l'utilisateur (déplacement de la souris, clics, frappe au clavier) vous donne également beaucoup de faux positifs. Pensez au même cas que ci-dessus, ou à un utilisateur qui regarde une vidéo.

Afin d'améliorer les comportements imparfaits décrits ci-dessus, j'utilise une combinaison des 3 méthodes: API de visibilité W3C, puis focus / flou et méthodes d'activité utilisateur afin de réduire le taux de faux positifs. Cela permet de gérer les événements suivants:

• Changer l'onglet du navigateur en un autre (précision de 100%, grâce à l'API W3C Page Visibility)
• Page potentiellement masquée par une autre fenêtre, par exemple en raison de Alt + Tab (probabiliste = pas 100% précis)
• L'attention des utilisateurs n'est peut-être pas concentrée sur la page HTML (probabiliste = pas précis à 100%)

Voici comment cela fonctionne: lorsque le document perd le focus, l'activité de l'utilisateur (comme le déplacement de la souris) sur le document est surveillée afin de déterminer si la fenêtre est visible ou non. La probabilité de visibilité de la page est inversement proportionnelle à l'heure de la dernière activité de l'utilisateur sur la page: si l'utilisateur ne fait aucune activité sur le document pendant une longue période, la page n'est probablement pas visible. Le code ci-dessous imite l'API W3C Page Visibility: il se comporte de la même manière mais a un petit taux de faux positifs. Il a l'avantage d'être multibrowser (testé sur Firefox 5, Firefox 10, MSIE 9, MSIE 7, Safari 5, Chrome 9).

    <div id = "x"> </div>

    <script>
    / **
    Enregistre le gestionnaire de l'événement pour l'objet donné.
    @param obj l'objet qui déclenchera l'événement
    @param evType le type d'événement: clic, pression de touche, survol de la souris, ...
    @param fn la fonction du gestionnaire d'événements
    @param isCapturing définit le mode d'événement (true = événement de capture, false = événement de propagation)
    @return true si le gestionnaire d'événements a été correctement attaché
    * /
    fonction addEvent (obj, evType, fn, isCapturing) {
      if (isCapturing == null) isCapturing = false; 
      if (obj.addEventListener) {
        // Firefox
        obj.addEventListener (evType, fn, isCapturing);
        return true;
      } else if (obj.attachEvent) {
        // MSIE
        var r = obj.attachEvent ('on' + evType, fn);
        return r;
      } autre {
        retour faux;
      }
    }

    // s'inscrire au changement potentiel de visibilité de page
    addEvent (document, "potentialvisilitychange", fonction (événement) {
      document.getElementById ("x"). innerHTML + = "potentialVisilityChange: potentialHidden =" + document.potentialHidden + ", document.potentialHiddenSince =" + document.potentialHiddenSince + "s <br>";
    });

    // s'inscrire à l'API de visibilité de page du W3C
    var caché = null;
    var visibilitéChange = null;
    if (typeof document.mozHidden! == "undefined") {
      hidden = "mozHidden";
      visibilitéChange = "mozvisibilitychange";
    } else if (typeof document.msHidden! == "undefined") {
      hidden = "msHidden";
      visibilitéChange = "msvisibilitychange";
    } else if (typeof document.webkitHidden! == "undefined") {
      hidden = "webkitHidden";
      visibilitéChange = "webkitvisibilitychange";
    } else if (typeof document.hidden! == "hidden") {
      caché = "caché";
      visibilitéChange = "visibilitéchange";
    }
    if (caché! = null && visibilitéChange! = null) {
      addEvent (document, visibilitéChange, fonction (événement) {
        document.getElementById ("x"). innerHTML + = visibilitéChange + ":" + caché + "=" + document [caché] + "<br>";
      });
    }


    var potentialPageVisibility = {
      pageVisibilityChangeThreshold: 3 * 3600, // en secondes
      init: fonction () {
        fonction setAsNotHidden () {
          var dispatchEventRequired = document.potentialHidden;
          document.potentialHidden = false;
          document.potentialHiddenSince = 0;
          if (dispatchEventRequired) dispatchPageVisibilityChangeEvent ();
        }

        fonction initPotentialHiddenDetection () {
          if (! hasFocusLocal) {
            // la fenêtre n'a pas le focus => vérifier l'activité des utilisateurs dans la fenêtre
            lastActionDate = new Date ();
            if (timeoutHandler! = null) {
              clearTimeout (timeoutHandler);
            }
            timeoutHandler = setTimeout (checkPageVisibility, potentialPageVisibility.pageVisibilityChangeThreshold * 1000 + 100); // +100 ms pour éviter les problèmes d'arrondi sous Firefox
          }
        }

        function dispatchPageVisibilityChangeEvent () {
          unifiedVisilityChangeEventDispatchAllowed = false;
          var evt = document.createEvent ("Event");
          evt.initEvent ("potentialvisilitychange", vrai, vrai);
          document.dispatchEvent (evt);
        }

        function checkPageVisibility () {
          var potentialHiddenDuration = (hasFocusLocal || lastActionDate == null? 0: Math.floor ((new Date (). getTime () - lastActionDate.getTime ()) / 1000));
                                        document.potentialHiddenSince = potentialHiddenDuration;
          if (potentialHiddenDuration> = potentialPageVisibility.pageVisibilityChangeThreshold &&! document.potentialHidden) {
            // seuil de changement de visibilité de la page raiched => augmenter le pair
            document.potentialHidden = true;
            dispatchPageVisibilityChangeEvent ();
          }
        }

        var lastActionDate = null;
        var hasFocusLocal = true;
        var hasMouseOver = true;
        document.potentialHidden = false;
        document.potentialHiddenSince = 0;
        var timeoutHandler = null;

        addEvent (document, "pageshow", fonction (événement) {
          document.getElementById ("x"). innerHTML + = "pageshow / doc: <br>";
        });
        addEvent (document, "pagehide", fonction (événement) {
          document.getElementById ("x"). innerHTML + = "pagehide / doc: <br>";
        });
        addEvent (fenêtre, "pageshow", fonction (événement) {
          document.getElementById ("x"). innerHTML + = "pageshow / win: <br>"; // levé lorsque la page s'affiche pour la première fois
        });
        addEvent (fenêtre, "pagehide", fonction (événement) {
          document.getElementById ("x"). innerHTML + = "pagehide / win: <br>"; // non levé
        });
        addEvent (document, "mousemove", fonction (événement) {
          lastActionDate = new Date ();
        });
        addEvent (document, "survol de la souris", fonction (événement) {
          hasMouseOver = true;
          setAsNotHidden ();
        });
        addEvent (document, "mouseout", fonction (événement) {
          hasMouseOver = false;
          initPotiallyHiddenDetection ();
        });
        addEvent (fenêtre, "flou", fonction (événement) {
          hasFocusLocal = false;
          initPotiallyHiddenDetection ();
        });
        addEvent (fenêtre, "focus", fonction (événement) {
          hasFocusLocal = true;
          setAsNotHidden ();
        });
        setAsNotHidden ();
      }
    }

    potentialPageVisibility.pageVisibilityChangeThreshold = 4; // 4 secondes pour les tests
    potentialPageVisibility.init ();
    </script>

Puisqu'il n'y a actuellement aucune solution multi-navigateur qui fonctionne sans faux positif, vous devriez mieux réfléchir à deux fois avant de désactiver l'activité périodique sur votre site Web.

Il y a une bibliothèque soignée disponible sur GitHub:

https://github.com/serkanyersen/ifvisible.js

Exemple:

// If page is visible right now
if( ifvisible.now() ){
  // Display pop-up
  openPopUp();
}

J'ai testé la version 1.0.1 sur tous les navigateurs que j'ai et je peux confirmer qu'elle fonctionne avec:

• IE9, IE10
• 26,0 FF
• Chrome 34.0

... et probablement toutes les versions plus récentes.

Ne fonctionne pas entièrement avec:

• IE8 - indique toujours que l'onglet / la fenêtre est actuellement actif ( .now()revient toujours truepour moi)

Utilisation: API de visibilité de page

document.addEventListener( 'visibilitychange' , function() {
    if (document.hidden) {
        console.log('bye');
    } else {
        console.log('well back');
    }
}, false );

Puis-je utiliser ? http://caniuse.com/#feat=pagevisibility

Je crée un chat Comet pour mon application et lorsque je reçois un message d'un autre utilisateur, j'utilise:

if(new_message){
    if(!document.hasFocus()){
        audio.play();
        document.title="Have new messages";
    }
    else{
        audio.stop();
        document.title="Application Name";
    } 
}

J'ai commencé à utiliser la réponse wiki communautaire, mais j'ai réalisé qu'elle ne détectait pas les événements alt-tab dans Chrome. En effet, il utilise la première source d'événement disponible, et dans ce cas, c'est l'API de visibilité des pages, qui dans Chrome ne semble pas suivre les tabulations alt.

J'ai décidé de modifier un peu le script pour garder une trace de tous les événements possibles pour les changements de focus de page. Voici une fonction que vous pouvez ajouter:

function onVisibilityChange(callback) {
    var visible = true;

    if (!callback) {
        throw new Error('no callback given');
    }

    function focused() {
        if (!visible) {
            callback(visible = true);
        }
    }

    function unfocused() {
        if (visible) {
            callback(visible = false);
        }
    }

    // Standards:
    if ('hidden' in document) {
        document.addEventListener('visibilitychange',
            function() {(document.hidden ? unfocused : focused)()});
    }
    if ('mozHidden' in document) {
        document.addEventListener('mozvisibilitychange',
            function() {(document.mozHidden ? unfocused : focused)()});
    }
    if ('webkitHidden' in document) {
        document.addEventListener('webkitvisibilitychange',
            function() {(document.webkitHidden ? unfocused : focused)()});
    }
    if ('msHidden' in document) {
        document.addEventListener('msvisibilitychange',
            function() {(document.msHidden ? unfocused : focused)()});
    }
    // IE 9 and lower:
    if ('onfocusin' in document) {
        document.onfocusin = focused;
        document.onfocusout = unfocused;
    }
    // All others:
    window.onpageshow = window.onfocus = focused;
    window.onpagehide = window.onblur = unfocused;
};

Utilisez-le comme ceci:

onVisibilityChange(function(visible) {
    console.log('the page is now', visible ? 'focused' : 'unfocused');
});

Cette version écoute tous les différents événements de visibilité et déclenche un rappel si l'un d'eux provoque un changement. Les gestionnaires focusedet unfocuseds'assurent que le rappel n'est pas appelé plusieurs fois si plusieurs API interceptent le même changement de visibilité.

C'est vraiment délicat. Il ne semble pas y avoir de solution compte tenu des exigences suivantes.

• La page contient des iframes sur lesquels vous n'avez aucun contrôle
• Vous souhaitez suivre le changement d'état de visibilité indépendamment du changement déclenché par un changement TAB (ctrl + tab) ou un changement de fenêtre (alt + tab)

Cela se produit parce que:

• L'API de visibilité de page peut vous informer de manière fiable d'un changement d'onglet (même avec des iframes), mais elle ne peut pas vous dire quand l'utilisateur change de fenêtre.
• L'écoute des événements de flou / focus de la fenêtre peut détecter les tabulations alt + et ctrl + tab, tant que l'iframe n'a pas le focus.

Compte tenu de ces restrictions, il est possible d'implémenter une solution qui combine - l'API de visibilité des pages - le flou / focus de la fenêtre - document.activeElement

Cela est capable de:

• 1) ctrl + tab lorsque la page parent a le focus: OUI
• 2) ctrl + tab lorsque iframe a le focus: OUI
• 3) alt + tab lorsque la page parent a le focus: OUI
• 4) alt + tab quand iframe a le focus: NO <- bummer

Lorsque l'iframe a le focus, vos événements flou / focus ne sont pas du tout invoqués et l'API de visibilité de la page ne se déclenche pas sur alt + tab.

J'ai construit sur la solution de @ AndyE et mis en œuvre cette (presque bonne) solution ici: https://dl.dropboxusercontent.com/u/2683925/estante-components/visibility_test1.html (désolé, j'ai eu quelques problèmes avec JSFiddle).

Ceci est également disponible sur Github: https://github.com/qmagico/estante-components

Cela fonctionne sur le chrome / chrome. Il fonctionne en quelque sorte sur Firefox, sauf qu'il ne charge pas le contenu iframe (une idée pourquoi?)

Quoi qu'il en soit, pour résoudre le dernier problème (4), la seule façon de le faire est d'écouter les événements de flou / focus sur l'iframe. Si vous avez un certain contrôle sur les iframes, vous pouvez utiliser l'API postMessage pour ce faire.

https://dl.dropboxusercontent.com/u/2683925/estante-components/visibility_test2.html

Je n'ai toujours pas testé cela avec suffisamment de navigateurs. Si vous pouvez trouver plus d'informations sur les cas où cela ne fonctionne pas, veuillez me le faire savoir dans les commentaires ci-dessous.

var visibilityChange = (function (window) {
    var inView = false;
    return function (fn) {
        window.onfocus = window.onblur = window.onpageshow = window.onpagehide = function (e) {
            if ({focus:1, pageshow:1}[e.type]) {
                if (inView) return;
                fn("visible");
                inView = true;
            } else if (inView) {
                fn("hidden");
                inView = false;
            }
        };
    };
}(this));

visibilityChange(function (state) {
    console.log(state);
});

http://jsfiddle.net/ARTsinn/JTxQY/

cela fonctionne pour moi sur chrome 67, firefox 67,

if(!document.hasFocus()) {
    // do stuff
}

vous pouvez utiliser:

(function () {

    var requiredResolution = 10; // ms
    var checkInterval = 1000; // ms
    var tolerance = 20; // percent


    var counter = 0;
    var expected = checkInterval / requiredResolution;
    //console.log('expected:', expected);

    window.setInterval(function () {
        counter++;
    }, requiredResolution);

    window.setInterval(function () {
        var deviation = 100 * Math.abs(1 - counter / expected);
        // console.log('is:', counter, '(off by', deviation , '%)');
        if (deviation > tolerance) {
            console.warn('Timer resolution not sufficient!');
        }
        counter = 0;
    }, checkInterval);

})();

En HTML 5, vous pouvez également utiliser:

• onpageshow: Script à exécuter lorsque la fenêtre devient visible
• onpagehide: Script à exécuter lorsque la fenêtre est masquée

Voir:

• https://developer.mozilla.org/en-US/docs/Web/Events/pageshow
• https://developer.mozilla.org/en-US/docs/Web/Events/pagehide

Ceci est une adaptation de la réponse d'Andy E.

Cela fera une tâche, par exemple actualiser la page toutes les 30 secondes, mais uniquement si la page est visible et ciblée.

Si la visibilité ne peut pas être détectée, seule la mise au point sera utilisée.

Si l'utilisateur concentre la page, celle-ci sera mise à jour immédiatement

La page ne se mettra à jour que 30 secondes après tout appel ajax

var windowFocused = true;
var timeOut2 = null;

$(function(){
  $.ajaxSetup ({
    cache: false
  });
  $("#content").ajaxComplete(function(event,request, settings){
       set_refresh_page(); // ajax call has just been made, so page doesn't need updating again for 30 seconds
   });
  // check visibility and focus of window, so as not to keep updating unnecessarily
  (function() {
      var hidden, change, vis = {
              hidden: "visibilitychange",
              mozHidden: "mozvisibilitychange",
              webkitHidden: "webkitvisibilitychange",
              msHidden: "msvisibilitychange",
              oHidden: "ovisibilitychange" /* not currently supported */
          };
      for (hidden in vis) {
          if (vis.hasOwnProperty(hidden) && hidden in document) {
              change = vis[hidden];
              break;
          }
      }
      document.body.className="visible";
      if (change){     // this will check the tab visibility instead of window focus
          document.addEventListener(change, onchange,false);
      }

      if(navigator.appName == "Microsoft Internet Explorer")
         window.onfocus = document.onfocusin = document.onfocusout = onchangeFocus
      else
         window.onfocus = window.onblur = onchangeFocus;

      function onchangeFocus(evt){
        evt = evt || window.event;
        if (evt.type == "focus" || evt.type == "focusin"){
          windowFocused=true; 
        }
        else if (evt.type == "blur" || evt.type == "focusout"){
          windowFocused=false;
        }
        if (evt.type == "focus"){
          update_page();  // only update using window.onfocus, because document.onfocusin can trigger on every click
        }

      }

      function onchange () {
        document.body.className = this[hidden] ? "hidden" : "visible";
        update_page();
      }

      function update_page(){
        if(windowFocused&&(document.body.className=="visible")){
          set_refresh_page(1000);
        }
      }


  })();
  set_refresh_page();
})

function get_date_time_string(){
  var d = new Date();
  var dT = [];
  dT.push(d.getDate());
  dT.push(d.getMonth())
  dT.push(d.getFullYear());
  dT.push(d.getHours());
  dT.push(d.getMinutes());
  dT.push(d.getSeconds());
  dT.push(d.getMilliseconds());
  return dT.join('_');
}

function do_refresh_page(){

// do tasks here

// e.g. some ajax call to update part of the page.

// (date time parameter will probably force the server not to cache)

//      $.ajax({
//        type: "POST",
//        url: "someUrl.php",
//        data: "t=" + get_date_time_string()+"&task=update",
//        success: function(html){
//          $('#content').html(html);
//        }
//      });

}

function set_refresh_page(interval){
  interval = typeof interval !== 'undefined' ? interval : 30000; // default time = 30 seconds
  if(timeOut2 != null) clearTimeout(timeOut2);
  timeOut2 = setTimeout(function(){
    if((document.body.className=="visible")&&windowFocused){
      do_refresh_page();
    }
    set_refresh_page();
  }, interval);
}

Pour une solution sans jQuery, consultez Visibility.js qui fournit des informations sur les états de trois pages

visible    ... page is visible
hidden     ... page is not visible
prerender  ... page is being prerendered by the browser

et aussi des wrappers pratiques pour setInterval

/* Perform action every second if visible */
Visibility.every(1000, function () {
    action();
});

/* Perform action every second if visible, every 60 sec if not visible */
Visibility.every(1000, 60*1000, function () {
    action();
});

Une solution de rechange pour les navigateurs plus anciens (IE <10; iOS <7) est également disponible

Une manière un peu plus compliquée serait d'utiliser setInterval()pour vérifier la position de la souris et comparer avec la dernière vérification. Si la souris n'a pas bougé dans un laps de temps défini, l'utilisateur est probablement inactif.

Cela a l'avantage supplémentaire de dire si l'utilisateur est inactif, au lieu de simplement vérifier si la fenêtre n'est pas active.

Comme de nombreuses personnes l'ont souligné, ce n'est pas toujours un bon moyen de vérifier si la fenêtre de l'utilisateur ou du navigateur est inactive, car l'utilisateur peut même ne pas utiliser la souris ou regarder une vidéo, ou similaire. Je suggère simplement une façon possible de vérifier l'inactivité.

Pour angular.js, voici une directive (basée sur la réponse acceptée) qui permettra à votre contrôleur de réagir à un changement de visibilité:

myApp.directive('reactOnWindowFocus', function($parse) {
    return {
        restrict: "A",
        link: function(scope, element, attrs) {
            var hidden = "hidden";
            var currentlyVisible = true;
            var functionOrExpression = $parse(attrs.reactOnWindowFocus);

          // Standards:
          if (hidden in document)
            document.addEventListener("visibilitychange", onchange);
          else if ((hidden = "mozHidden") in document)
            document.addEventListener("mozvisibilitychange", onchange);
          else if ((hidden = "webkitHidden") in document)
            document.addEventListener("webkitvisibilitychange", onchange);
          else if ((hidden = "msHidden") in document)
            document.addEventListener("msvisibilitychange", onchange);
          else if ("onfocusin" in document) {
                // IE 9 and lower:
            document.onfocusin = onshow;
                document.onfocusout = onhide;
          } else {
                // All others:
            window.onpageshow = window.onfocus = onshow;
                window.onpagehide = window.onblur = onhide;
            }

          function onchange (evt) {
                //occurs both on leaving and on returning
                currentlyVisible = !currentlyVisible;
                doSomethingIfAppropriate();
          }

            function onshow(evt) {
                //for older browsers
                currentlyVisible = true;
                doSomethingIfAppropriate();
            }

            function onhide(evt) {
                //for older browsers
                currentlyVisible = false;
                doSomethingIfAppropriate();
            }

            function doSomethingIfAppropriate() {
                if (currentlyVisible) {
                    //trigger angular digest cycle in this scope
                    scope.$apply(function() {
                        functionOrExpression(scope);
                    });
                }
            }
        }
    };

});

Vous pouvez l'utiliser comme cet exemple:, <div react-on-window-focus="refresh()">où refresh()est une fonction de portée dans la portée de tout contrôleur qui est dans la portée.

Voici une solution solide et moderne. (Court un doux 👌🏽)

document.addEventListener("visibilitychange", () => {
  console.log( document.hasFocus() )
})

Cela configurera un écouteur pour qu'il se déclenche lorsqu'un événement de visibilité est déclenché, ce qui pourrait être un focus ou un flou.

Si vous souhaitez agir sur l' ensemble du flou du navigateur : comme je l'ai dit, si le navigateur perd le focus, aucun des événements suggérés ne se déclenche. Mon idée est de compter en boucle et de réinitialiser le compteur si un événement se déclenche. Si le compteur atteint une limite, je fais une location.href vers une autre page. Cela se déclenche également si vous travaillez sur des outils de développement.

var iput=document.getElementById("hiddenInput");
   ,count=1
   ;
function check(){
         count++;
         if(count%2===0){
           iput.focus();
         }
         else{
           iput.blur();
         }
         iput.value=count;  
         if(count>3){
           location.href="http://Nirwana.com";
         }              
         setTimeout(function(){check()},1000);
}   
iput.onblur=function(){count=1}
iput.onfocus=function(){count=1}
check();

Il s'agit d'un projet testé avec succès sur FF.