| ;(function (global) { | |
| var lastId = -1; | |
| // Visibility.js allow you to know, that your web page is in the background | |
| // tab and thus not visible to the user. This library is wrap under | |
| // Page Visibility API. It fix problems with different vendor prefixes and | |
| // add high-level useful functions. | |
| var self = { | |
| // Call callback only when page become to visible for user or | |
| // call it now if page is visible now or Page Visibility API | |
| // doesn’t supported. | |
| // | |
| // Return false if API isn’t supported, true if page is already visible | |
| // or listener ID (you can use it in `unbind` method) if page isn’t | |
| // visible now. | |
| // | |
| // Visibility.onVisible(function () { | |
| // startIntroAnimation(); | |
| // }); | |
| onVisible: function (callback) { | |
| var support = self.isSupported(); | |
| if ( !support || !self.hidden() ) { | |
| callback(); | |
| return support; | |
| } | |
| var listener = self.change(function (e, state) { | |
| if ( !self.hidden() ) { | |
| self.unbind(listener); | |
| callback(); | |
| } | |
| }); | |
| return listener; | |
| }, | |
| // Call callback when visibility will be changed. First argument for | |
| // callback will be original event object, second will be visibility | |
| // state name. | |
| // | |
| // Return listener ID to unbind listener by `unbind` method. | |
| // | |
| // If Page Visibility API doesn’t supported method will be return false | |
| // and callback never will be called. | |
| // | |
| // Visibility.change(function(e, state) { | |
| // Statistics.visibilityChange(state); | |
| // }); | |
| // | |
| // It is just proxy to `visibilitychange` event, but use vendor prefix. | |
| change: function (callback) { | |
| if ( !self.isSupported() ) { | |
| return false; | |
| } | |
| lastId += 1; | |
| var number = lastId; | |
| self._callbacks[number] = callback; | |
| self._listen(); | |
| return number; | |
| }, | |
| // Remove `change` listener by it ID. | |
| // | |
| // var id = Visibility.change(function(e, state) { | |
| // firstChangeCallback(); | |
| // Visibility.unbind(id); | |
| // }); | |
| unbind: function (id) { | |
| delete self._callbacks[id]; | |
| }, | |
| // Call `callback` in any state, expect “prerender”. If current state | |
| // is “prerender” it will wait until state will be changed. | |
| // If Page Visibility API doesn’t supported, it will call `callback` | |
| // immediately. | |
| // | |
| // Return false if API isn’t supported, true if page is already after | |
| // prerendering or listener ID (you can use it in `unbind` method) | |
| // if page is prerended now. | |
| // | |
| // Visibility.afterPrerendering(function () { | |
| // Statistics.countVisitor(); | |
| // }); | |
| afterPrerendering: function (callback) { | |
| var support = self.isSupported(); | |
| var prerender = 'prerender'; | |
| if ( !support || prerender != self.state() ) { | |
| callback(); | |
| return support; | |
| } | |
| var listener = self.change(function (e, state) { | |
| if ( prerender != state ) { | |
| self.unbind(listener); | |
| callback(); | |
| } | |
| }); | |
| return listener; | |
| }, | |
| // Return true if page now isn’t visible to user. | |
| // | |
| // if ( !Visibility.hidden() ) { | |
| // VideoPlayer.play(); | |
| // } | |
| // | |
| // It is just proxy to `document.hidden`, but use vendor prefix. | |
| hidden: function () { | |
| return !!(self._doc.hidden || self._doc.webkitHidden); | |
| }, | |
| // Return visibility state: 'visible', 'hidden' or 'prerender'. | |
| // | |
| // if ( 'prerender' == Visibility.state() ) { | |
| // Statistics.pageIsPrerendering(); | |
| // } | |
| // | |
| // Don’t use `Visibility.state()` to detect, is page visible, because | |
| // visibility states can extend in next API versions. | |
| // Use more simpler and general `Visibility.hidden()` for this cases. | |
| // | |
| // It is just proxy to `document.visibilityState`, but use | |
| // vendor prefix. | |
| state: function () { | |
| return self._doc.visibilityState || | |
| self._doc.webkitVisibilityState || | |
| 'visible'; | |
| }, | |
| // Return true if browser support Page Visibility API. | |
| // refs: https://developer.mozilla.org/en-US/docs/Web/API/Page_Visibility_API | |
| // | |
| // if ( Visibility.isSupported() ) { | |
| // Statistics.startTrackingVisibility(); | |
| // Visibility.change(function(e, state)) { | |
| // Statistics.trackVisibility(state); | |
| // }); | |
| // } | |
| isSupported: function () { | |
| return self._doc.hidden !== undefined || self._doc.webkitHidden !== undefined; | |
| }, | |
| // Link to document object to change it in tests. | |
| _doc: document || {}, | |
| // Callbacks from `change` method, that wait visibility changes. | |
| _callbacks: { }, | |
| // Listener for `visibilitychange` event. | |
| _change: function(event) { | |
| var state = self.state(); | |
| for ( var i in self._callbacks ) { | |
| self._callbacks[i].call(self._doc, event, state); | |
| } | |
| }, | |
| // Set listener for `visibilitychange` event. | |
| _listen: function () { | |
| if ( self._init ) { | |
| return; | |
| } | |
| var event = 'visibilitychange'; | |
| if ( self._doc.webkitVisibilityState ) { | |
| event = 'webkit' + event; | |
| } | |
| var listener = function () { | |
| self._change.apply(self, arguments); | |
| }; | |
| if ( self._doc.addEventListener ) { | |
| self._doc.addEventListener(event, listener); | |
| } else { | |
| self._doc.attachEvent(event, listener); | |
| } | |
| self._init = true; | |
| } | |
| }; | |
| if ( typeof(module) != 'undefined' && module.exports ) { | |
| module.exports = self; | |
| } else { | |
| global.Visibility = self; | |
| } | |
| })(this); | |