* Heartbeat is a simple server polling API that sends XHR requests to

 * the server every 15 - 60 seconds and triggers events (or callbacks) upon

 * receiving data. Currently these 'ticks' handle transports for post locking,

 * login-expiration warnings, autosave, and related tasks while a user is logged in.

 * Available PHP filters (in ajax-actions.php):

 * Custom jQuery events:

 * - heartbeat-send

 * - heartbeat-tick

 * - heartbeat-error

 * - heartbeat-connection-lost

 * - heartbeat-connection-restored

 * - heartbeat-nonces-expired

 *

( function( $, window, undefined ) {

		var $document = $(document),

			settings = {

				// Suspend/resume

				suspend: false,

				// Whether suspending is enabled

				suspendEnabled: true,

				// Current screen id, defaults to the JS global 'pagenow' when present (in the admin) or 'front'

				screenId: '',

				// XHR request URL, defaults to the JS global 'ajaxurl' when present

				url: '',

				// Timestamp, start of the last connection request

				lastTick: 0,

				// Container for the enqueued items

				queue: {},

				// Connect interval (in seconds)

				mainInterval: 60,

				// Used when the interval is set to 5 sec. temporarily

				tempInterval: 0,

				// Used when the interval is reset

				originalInterval: 0,

				// Used to limit the number of AJAX requests.

				minimalInterval: 0,

				// Used together with tempInterval

				countdown: 0,

				// Whether a connection is currently in progress

				connecting: false,

				// Whether a connection error occurred

				connectionError: false,

				// Used to track non-critical errors

				errorcount: 0,

				// Whether at least one connection has completed successfully

				hasConnected: false,

				// Whether the current browser window is in focus and the user is active

				hasFocus: true,

				// Timestamp, last time the user was active. Checked every 30 sec.

				userActivity: 0,

				// Flags whether events tracking user activity were set

				userActivityEvents: false,

				checkFocusTimer: 0,

				beatTimer: 0

			};

		 * Set local vars and events, then start

		 * @access private

		 *

		 * @return void

		function initialize() {

			var options, hidden, visibilityState, visibilitychange;

			if ( typeof window.pagenow === 'string' ) {

				settings.screenId = window.pagenow;

			}

			if ( typeof window.ajaxurl === 'string' ) {

				settings.url = window.ajaxurl;

			}

			// Pull in options passed from PHP

			if ( typeof window.heartbeatSettings === 'object' ) {

				options = window.heartbeatSettings;

				// The XHR URL can be passed as option when window.ajaxurl is not set

				if ( ! settings.url && options.ajaxurl ) {

					settings.url = options.ajaxurl;

				}

				// The interval can be from 15 to 120 sec. and can be set temporarily to 5 sec.

				// It can be set in the initial options or changed later from JS and/or from PHP.

				if ( options.interval ) {

					settings.mainInterval = options.interval;

					if ( settings.mainInterval < 15 ) {

						settings.mainInterval = 15;

					} else if ( settings.mainInterval > 120 ) {

						settings.mainInterval = 120;

					}

				}

				// Used to limit the number of AJAX requests. Overrides all other intervals if they are shorter.

				// Needed for some hosts that cannot handle frequent requests and the user may exceed the allocated server CPU time, etc.

				// The minimal interval can be up to 600 sec. however setting it to longer than 120 sec. will limit or disable

				// some of the functionality (like post locks).

				// Once set at initialization, minimalInterval cannot be changed/overriden.

				if ( options.minimalInterval ) {

					options.minimalInterval = parseInt( options.minimalInterval, 10 );

					settings.minimalInterval = options.minimalInterval > 0 && options.minimalInterval <= 600 ? options.minimalInterval * 1000 : 0;

				}

				if ( settings.minimalInterval && settings.mainInterval < settings.minimalInterval ) {

					settings.mainInterval = settings.minimalInterval;

				}

				// 'screenId' can be added from settings on the front-end where the JS global 'pagenow' is not set

				if ( ! settings.screenId ) {

					settings.screenId = options.screenId || 'front';

				}

				if ( options.suspension === 'disable' ) {

					settings.suspendEnabled = false;

				}

			}

			// Convert to milliseconds

			settings.mainInterval = settings.mainInterval * 1000;

			settings.originalInterval = settings.mainInterval;

			// Switch the interval to 120 sec. by using the Page Visibility API.

			// If the browser doesn't support it (Safari < 7, Android < 4.4, IE < 10), the interval

			// will be increased to 120 sec. after 5 min. of mouse and keyboard inactivity.

			if ( typeof document.hidden !== 'undefined' ) {

				hidden = 'hidden';

				visibilitychange = 'visibilitychange';

				visibilityState = 'visibilityState';

			} else if ( typeof document.msHidden !== 'undefined' ) { // IE10

				hidden = 'msHidden';

				visibilitychange = 'msvisibilitychange';

				visibilityState = 'msVisibilityState';

			} else if ( typeof document.webkitHidden !== 'undefined' ) { // Android

				hidden = 'webkitHidden';

				visibilitychange = 'webkitvisibilitychange';

				visibilityState = 'webkitVisibilityState';

			}

			if ( hidden ) {

				if ( document[hidden] ) {

					settings.hasFocus = false;

				}

				$document.on( visibilitychange + '.wp-heartbeat', function() {

					if ( document[visibilityState] === 'hidden' ) {

						blurred();

						window.clearInterval( settings.checkFocusTimer );

					} else {

						focused();

						if ( document.hasFocus ) {

							settings.checkFocusTimer = window.setInterval( checkFocus, 10000 );

						}

					}

				});

			}

			// Use document.hasFocus() if available.

			if ( document.hasFocus ) {

				settings.checkFocusTimer = window.setInterval( checkFocus, 10000 );

			}

			$(window).on( 'unload.wp-heartbeat', function() {

				// Don't connect any more

				settings.suspend = true;

				// Abort the last request if not completed

				if ( settings.xhr && settings.xhr.readyState !== 4 ) {

					settings.xhr.abort();

				}

			});

			// Check for user activity every 30 seconds.

			window.setInterval( checkUserActivity, 30000 );

			// Start one tick after DOM ready

			$document.ready( function() {

				settings.lastTick = time();

				scheduleNextTick();

			});

		/**

		 * Return the current time according to the browser

		 *

		 * @access private

		 *

		 * @return int

		 */

		function time() {

		/**

		 * Check if the iframe is from the same origin

		 *

		 * @access private

		 *

		 * @return bool

		 */

			// Need to compare strings as WebKit doesn't throw JS errors when iframes have different origin.

			// It throws uncatchable exceptions.

				if ( src.indexOf( origin ) !== 0 ) {

				}

				if ( frame.contentWindow.document ) {

				}

		/**

		 * Check if the document's focus has changed

		 *

		 * @access private

		 *

		 * @return void

		 */

		function checkFocus() {

			if ( settings.hasFocus && ! document.hasFocus() ) {

				blurred();

			} else if ( ! settings.hasFocus && document.hasFocus() ) {

				focused();

			}

		}

		/**

		 * Set error state and fire an event on XHR errors or timeout

		 *

		 * @access private

		 *

		 * @param string error The error type passed from the XHR

		 * @param int status The HTTP status code passed from jqXHR (200, 404, 500, etc.)

		 * @return void

		 */

		function setErrorState( error, status ) {

					case 'error':

						if ( 503 === status && settings.hasConnected ) {

							trigger = true;

							break;

						}

						/* falls through */

						settings.errorcount++;

						if ( settings.errorcount > 2 && settings.hasConnected ) {

						}

				if ( trigger && ! hasConnectionError() ) {

					settings.connectionError = true;

					$document.trigger( 'heartbeat-connection-lost', [error, status] );

			}

		}

		/**

		 * Clear the error state and fire an event

		 *

		 * @access private

		 *

		 * @return void

		 */

		function clearErrorState() {

			// Has connected successfully

			settings.hasConnected = true;

			if ( hasConnectionError() ) {

				settings.errorcount = 0;

				settings.connectionError = false;

				$document.trigger( 'heartbeat-connection-restored' );

		/**

		 * Gather the data and connect to the server

		 *

		 * @access private

		 *

		 * @return void

		 */

			var ajaxData, heartbeatData;

			// If the connection to the server is slower than the interval,

			// heartbeat connects as soon as the previous connection's response is received.

			if ( settings.connecting || settings.suspend ) {

			settings.lastTick = time();

			heartbeatData = $.extend( {}, settings.queue );

			// Clear the data queue, anything added after this point will be send on the next tick

			settings.queue = {};

			$document.trigger( 'heartbeat-send', [ heartbeatData ] );

			ajaxData = {

				data: heartbeatData,

				interval: settings.tempInterval ? settings.tempInterval / 1000 : settings.mainInterval / 1000,

				_nonce: typeof window.heartbeatSettings === 'object' ? window.heartbeatSettings.nonce : '',

				action: 'heartbeat',

				screen_id: settings.screenId,

				has_focus: settings.hasFocus

			};

			settings.connecting = true;

			settings.xhr = $.ajax({

				url: settings.url,

				data: ajaxData,

			}).always( function() {

				settings.connecting = false;