Changeset 26169

Timestamp:

11/14/2013 06:40:03 PM (11 years ago)

Author:

azaozz

Message:

Heartbeat: clean up code style, better naming, better code structure. Props carldanley, props evansolomon.
Changes:

• Add connectNow() public method to trigger a connection immediately.
• Remove the "skipping" when no data to send.
• Change the default interval to 60 sec.
• Fix resetting the next connection time when changing the interval.

See #25073.

Location:

trunk/src

Files:

• wp-admin/includes/post.php (modified) (1 diff)
• wp-admin/js/inline-edit-post.js (modified) (1 diff)
• wp-admin/js/post.js (modified) (1 diff)
• wp-includes/js/heartbeat.js (modified) (11 diffs)

trunk/src/wp-admin/includes/post.php

@@ -1186 +1186 @@
     $user = isset( $lock[1] ) ? $lock[1] : get_post_meta( $post->ID, '_edit_last', true );
 
-    $time_window = apply_filters( 'wp_check_post_lock_window', 120 );
+    $time_window = apply_filters( 'wp_check_post_lock_window', 150 );
 
     if ( $time && $time > time() - $time_window && $user != get_current_user_id() )

trunk/src/wp-admin/js/inline-edit-post.js

@@ -326 +326 @@
     if ( check.length )
         data['wp-check-locked-posts'] = check;
+}).ready( function() {
+    // Set the heartbeat interval to 15 sec.
+    if ( typeof wp !== 'undefined' && wp.heartbeat ) {
+        wp.heartbeat.setInterval( 15 );
+    }
 });
 

trunk/src/wp-admin/js/post.js

@@ -371 +371 @@
         }
     }).filter(':visible').find('.wp-tab-first').focus();
+    
+    // Set the heartbeat interval to 15 sec. if post lock dialogs are enabled
+    if ( typeof wp !== 'undefined' && wp.heartbeat && $('#post-lock-dialog').length ) {
+        wp.heartbeat.setInterval( 15 );
+    }
 
     // multi-taxonomies

trunk/src/wp-includes/js/heartbeat.js

@@ -7 +7 @@
  *
  * Heartbeat is a simple server polling API that sends XHR requests to
- * the server every 15 seconds and triggers events (or callbacks) upon
+ * 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, and related tasks while a user is logged in.
  *
- * Available filters in ajax-actions.php:
+ * Available PHP filters (in ajax-actions.php):
  * - heartbeat_received
  * - heartbeat_send
@@ -20 +20 @@
  * @see wp_ajax_nopriv_heartbeat(), wp_ajax_heartbeat()
  *
+ * Custom jQuery events:
+ * - heartbeat-send
+ * - heartbeat-tick
+ * - heartbeat-error
+ * - heartbeat-connection-lost
+ * - heartbeat-connection-restored
+ * - heartbeat-nonces-expired
+ *
  * @since 3.6.0
  */
 
- // Ensure the global `wp` object exists.
-window.wp = window.wp || {};
-
-(function($){
+( function( $, window, undefined ) {
     var Heartbeat = function() {
-        var self = this,
-            running,
-            beat,
-            screenId = typeof pagenow != 'undefined' ? pagenow : '',
-            url = typeof ajaxurl != 'undefined' ? ajaxurl : '',
-            settings,
-            tick = 0,
-            queue = {},
-            interval,
-            connecting,
-            countdown = 0,
-            errorcount = 0,
-            tempInterval,
-            hasFocus = true,
-            isUserActive,
-            userActiveEvents,
-            winBlurTimeout,
-            frameBlurTimeout = -1,
-            hasConnectionError = null;
-
-        /**
-         * Returns a boolean that's indicative of whether or not there is a connection error
-         *
-         * @returns boolean
-         */
-        this.hasConnectionError = function() {
-            return !! hasConnectionError;
-        };
-
-        if ( typeof( window.heartbeatSettings ) == 'object' ) {
-            settings = $.extend( {}, window.heartbeatSettings );
-
-            // Add private vars
-            url = settings.ajaxurl || url;
-            delete settings.ajaxurl;
-            delete settings.nonce;
-
-            interval = settings.interval || 15; // default interval
-            delete settings.interval;
-            // The interval can be from 15 to 60 sec. and can be set temporarily to 5 sec.
-            if ( interval < 15 )
-                interval = 15;
-            else if ( interval > 60 )
-                interval = 60;
-
-            interval = interval * 1000;
-
-            // 'screenId' can be added from settings on the front-end where the JS global 'pagenow' is not set
-            screenId = screenId || settings.screenId || 'front';
-            delete settings.screenId;
-
-            // Add or overwrite public vars
-            $.extend( this, settings );
-        }
-
-        function time(s) {
-            if ( s )
-                return parseInt( (new Date()).getTime() / 1000 );
-
+        var $document = $(document),
+            settings = {
+                // Used to stop the "beat"
+                isRunning: 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 together with tempInterval
+                countdown: 0,
+
+                // Whether a connection is currently in progress
+                connecting: false,
+
+                // Whether a connection error occured
+                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,
+
+                // References to various timeouts
+                beatTimer: 0,
+                winBlurTimer: 0,
+                frameBlurTimer: 0
+            };
+
+        /**
+         * Set local vars and events, then start
+         *
+         * @access private
+         *
+         * @return void
+         */
+        function initialize() {
+            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' ) {
+                var 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 60 sec. and can be set temporarily to 5 sec.
+                if ( options.interval ) {
+                    settings.mainInterval = options.interval;
+
+                    if ( settings.mainInterval < 15 ) {
+                        settings.mainInterval = 15;
+                    } else if ( settings.mainInterval > 60 ) {
+                        settings.mainInterval = 60;
+                    }
+                }
+
+                // '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';
+                }
+            }
+
+            // Convert to milliseconds
+            settings.mainInterval = settings.mainInterval * 1000;
+            settings.originalInterval = settings.mainInterval;
+
+            // Set focus/blur events on the window
+            $(window).on( 'blur.wp-heartbeat-focus', function() {
+                setFrameFocusEvents();
+                // We don't know why the 'blur' was fired. Either the user clicked in an iframe or outside the browser.
+                // Running blurred() after some timeout lets us cancel it if the user clicked in an iframe.
+                settings.winBlurTimer = window.setTimeout( function(){ blurred(); }, 500 );
+            }).on( 'focus.wp-heartbeat-focus', function() {
+                removeFrameFocusEvents();
+                focused();
+            }).on( 'unload.wp-heartbeat', function() {
+                // Don't connect any more
+                settings.isRunning = false;
+            });
+
+            // Check for user activity every 30 seconds.
+            window.setInterval( function(){ 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() {
             return (new Date()).getTime();
         }
 
+        /**
+         * Check if the iframe is from the same origin
+         *
+         * @access private
+         *
+         * @return bool
+         */
         function isLocalFrame( frame ) {
             var origin, src = frame.src;
 
+            // Need to compare strings as WebKit doesn't throw JS errors when iframes have different origin.
+            // It throws uncatchable exceptions.
             if ( src && /^https?:\/\//.test( src ) ) {
                 origin = window.location.origin ? window.location.origin : window.location.protocol + '//' + window.location.host;
 
-                if ( src.indexOf( origin ) !== 0 )
+                if ( src.indexOf( origin ) !== 0 ) {
                     return false;
+                }
             }
 
             try {
-                if ( frame.contentWindow.document )
+                if ( frame.contentWindow.document ) {
                     return true;
+                }
             } catch(e) {}
 
@@ -108 +199 @@
         }
 
-        // Set error state and fire an event on XHR errors or timeout
-        function errorstate( error, status ) {
+        /**
+         * 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 ) {
             var trigger;
 
@@ -121 +220 @@
                         trigger = true;
                         break;
+                    case 'error':
+                        if ( 503 === status && settings.hasConnected ) {
+                            trigger = true;
+                            break;
+                        }
+                        // Pass through other error statuses
                     case 'parsererror':
-                    case 'error':
                     case 'empty':
                     case 'unknown':
-                        errorcount++;
-
-                        if ( errorcount > 2 )
+                        settings.errorcount++;
+
+                        if ( settings.errorcount > 2 && settings.hasConnected ) {
                             trigger = true;
+                        }
 
                         break;
                 }
 
-                if ( 503 == status && false === hasConnectionError ) {
-                    trigger = true;
-                }
-
-                if ( trigger && ! self.hasConnectionError() ) {
-                    hasConnectionError = true;
+                if ( trigger && ! hasConnectionError() ) {
+                    settings.connectionError = true;
                     $(document).trigger( 'heartbeat-connection-lost', [error, status] );
                 }
-            } else if ( self.hasConnectionError() ) {
-                errorcount = 0;
-                hasConnectionError = false;
-                $(document).trigger( 'heartbeat-connection-restored' );
-            } else if ( null === hasConnectionError ) {
-                hasConnectionError = false;
-            }
-        }
-
+            }
+        }
+
+        /**
+         * 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
+         */
         function connect() {
-            var send = {}, data, i, empty = true,
-            nonce = typeof window.heartbeatSettings == 'object' ? window.heartbeatSettings.nonce : '';
-            tick = time();
-
-            data = $.extend( {}, queue );
+            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 ) {
+                return;
+            }
+
+            settings.lastTick = time();
+
+            heartbeatData = $.extend( {}, settings.queue );
             // Clear the data queue, anything added after this point will be send on the next tick
-            queue = {};
-
-            $(document).trigger( 'heartbeat-send', [data] );
-
-            for ( i in data ) {
-                if ( data.hasOwnProperty( i ) ) {
-                    empty = false;
-                    break;
-                }
-            }
-
-            // If nothing to send (nothing is expecting a response),
-            // schedule the next tick and bail
-            if ( empty && ! self.hasConnectionError() ) {
-                connecting = false;
-                next();
-                return;
-            }
-
-            send.data = data;
-            send.interval = interval / 1000;
-            send._nonce = nonce;
-            send.action = 'heartbeat';
-            send.screen_id = screenId;
-            send.has_focus = hasFocus;
-
-            connecting = true;
-            self.xhr = $.ajax({
-                url: url,
+            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,
                 type: 'post',
                 timeout: 30000, // throw an error if not completed after 30 sec.
-                data: send,
+                data: ajaxData,
                 dataType: 'json'
+            }).always( function() {
+                settings.connecting = false;
+                scheduleNextTick();
             }).done( function( response, textStatus, jqXHR ) {
-                var new_interval;
-
-                if ( ! response )
-                    return errorstate( 'empty' );
-
-                // Clear error state
-                if ( self.hasConnectionError() )
-                    errorstate();
+                var newInterval;
+
+                if ( ! response ) {
+                    setErrorState( 'empty' );
+                    return;
+                }
+
+                clearErrorState();
 
                 if ( response.nonces_expired ) {
-                    $(document).trigger( 'heartbeat-nonces-expired' );
+                    $document.trigger( 'heartbeat-nonces-expired' );
                     return;
                 }
@@ -207 +323 @@
                 // Change the interval from PHP
                 if ( response.heartbeat_interval ) {
-                    new_interval = response.heartbeat_interval;
+                    newInterval = response.heartbeat_interval;
                     delete response.heartbeat_interval;
                 }
 
-                self.tick( response, textStatus, jqXHR );
-
-                // do this last, can trigger the next XHR if connection time > 5 sec. and new_interval == 'fast'
-                if ( new_interval )
-                    self.interval.call( self, new_interval );
-            }).always( function() {
-                connecting = false;
-                next();
+                $document.trigger( 'heartbeat-tick', [response, textStatus, jqXHR] );
+
+                // Do this last, can trigger the next XHR if connection time > 5 sec. and newInterval == 'fast'
+                if ( newInterval ) {
+                    setInterval( newInterval );
+                }
             }).fail( function( jqXHR, textStatus, error ) {
-                errorstate( textStatus || 'unknown', jqXHR.status );
-                self.error( jqXHR, textStatus, error );
+                setErrorState( textStatus || 'unknown', jqXHR.status );
+                $document.trigger( 'heartbeat-error', [jqXHR, textStatus, error] );
             });
         }
 
-        function next() {
-            var delta = time() - tick, t = interval;
-
-            if ( ! running )
+        /**
+         * Schedule the next connection
+         *
+         * Fires immediately if the connection time is longer than the interval.
+         *
+         * @access private
+         *
+         * @return void
+         */
+        function scheduleNextTick() {
+            var delta = time() - settings.lastTick,
+                interval = settings.mainInterval;
+
+            if ( ! settings.isRunning ) {
                 return;
-
-            if ( ! hasFocus ) {
-                t = 100000; // 100 sec. Post locks expire after 120 sec.
-            } else if ( countdown > 0 && tempInterval ) {
-                t = tempInterval;
-                countdown--;
-            }
-
-            window.clearTimeout(beat);
-
-            if ( delta < t ) {
-                beat = window.setTimeout(
-                    function(){
-                        if ( running )
+            }
+
+            if ( ! settings.hasFocus ) {
+                interval = 120000; // 120 sec. Post locks expire after 150 sec.
+            } else if ( settings.countdown > 0 && settings.tempInterval ) {
+                interval = settings.tempInterval;
+                settings.countdown--;
+
+                if ( settings.countdown < 1 ) {
+                    settings.tempInterval = 0;
+                }
+            }
+
+            window.clearTimeout( settings.beatTimer );
+
+            if ( delta < interval ) {
+                settings.beatTimer = window.setTimeout(
+                    function() {
                             connect();
                     },
-                    t - delta
+                    interval - delta
                 );
             } else {
@@ -253 +381 @@
         }
 
+        /**
+         * Set the internal state when the browser window looses focus
+         *
+         * @access private
+         *
+         * @return void
+         */
         function blurred() {
-            window.clearTimeout(winBlurTimeout);
-            window.clearTimeout(frameBlurTimeout);
-            winBlurTimeout = frameBlurTimeout = 0;
-
-            hasFocus = false;
-        }
-
+            clearFocusTimers();
+            settings.hasFocus = false;
+        }
+
+        /**
+         * Set the internal state when the browser window is focused
+         *
+         * @access private
+         *
+         * @return void
+         */
         function focused() {
-            window.clearTimeout(winBlurTimeout);
-            window.clearTimeout(frameBlurTimeout);
-            winBlurTimeout = frameBlurTimeout = 0;
-
-            isUserActive = time();
-
-            if ( hasFocus )
-                return;
-
-            hasFocus = true;
-            window.clearTimeout(beat);
-
-            if ( ! connecting )
-                next();
-        }
-
-        function setFrameEvents() {
-            $('iframe').each( function( i, frame ){
-                if ( ! isLocalFrame( frame ) )
+            clearFocusTimers();
+            settings.userActivity = time();
+
+            if ( ! settings.hasFocus ) {
+                settings.hasFocus = true;
+                scheduleNextTick();
+            }
+        }
+
+        /**
+         * Add focus/blur events to all local iframes
+         *
+         * Used to detect when focus is moved from the main window to an iframe
+         *
+         * @access private
+         *
+         * @return void
+         */
+        function setFrameFocusEvents() {
+            $('iframe').each( function( i, frame ) {
+                if ( ! isLocalFrame( frame ) ) {
                     return;
-
-                if ( $.data( frame, 'wp-heartbeat-focus' ) )
+                }
+
+                if ( $.data( frame, 'wp-heartbeat-focus' ) ) {
                     return;
+                }
 
                 $.data( frame, 'wp-heartbeat-focus', 1 );
 
-                $( frame.contentWindow ).on( 'focus.wp-heartbeat-focus', function(e) {
+                $( frame.contentWindow ).on( 'focus.wp-heartbeat-focus', function() {
                     focused();
-                }).on('blur.wp-heartbeat-focus', function(e) {
-                    setFrameEvents();
-                    frameBlurTimeout = window.setTimeout( function(){ blurred(); }, 500 );
+                }).on('blur.wp-heartbeat-focus', function() {
+                    setFrameFocusEvents();
+                    // We don't know why 'blur' was fired. Either the user clicked in the main window or outside the browser.
+                    // Running blurred() after some timeout lets us cancel it if the user clicked in the main window.
+                    settings.frameBlurTimer = window.setTimeout( function(){ blurred(); }, 500 );
                 });
             });
         }
 
-        $(window).on( 'blur.wp-heartbeat-focus', function(e) {
-            setFrameEvents();
-            winBlurTimeout = window.setTimeout( function(){ blurred(); }, 500 );
-        }).on( 'focus.wp-heartbeat-focus', function() {
+        /**
+         * Remove the focus/blur events to all local iframes
+         *
+         * @access private
+         *
+         * @return void
+         */
+        function removeFrameFocusEvents() {
             $('iframe').each( function( i, frame ) {
-                if ( !isLocalFrame( frame ) )
+                if ( ! isLocalFrame( frame ) ) {
                     return;
+                }
 
                 $.removeData( frame, 'wp-heartbeat-focus' );
                 $( frame.contentWindow ).off( '.wp-heartbeat-focus' );
             });
-
-            focused();
-        });
-
+        }
+
+        /**
+         * Clear the reset timers for focus/blur events on the window and iframes
+         *
+         * @access private
+         *
+         * @return void
+         */
+        function clearFocusTimers() {
+            window.clearTimeout( settings.winBlurTimer );
+            window.clearTimeout( settings.frameBlurTimer );
+        }
+
+        /**
+         * Runs when the user becomes active after a period of inactivity
+         *
+         * @access private
+         *
+         * @return void
+         */
         function userIsActive() {
-            userActiveEvents = false;
-            $(document).off( '.wp-heartbeat-active' );
+            settings.userActivityEvents = false;
+            $document.off( '.wp-heartbeat-active' );
+
             $('iframe').each( function( i, frame ) {
-                if ( ! isLocalFrame( frame ) )
+                if ( ! isLocalFrame( frame ) ) {
                     return;
+                }
 
                 $( frame.contentWindow ).off( '.wp-heartbeat-active' );
@@ -325 +494 @@
         }
 
-        // Set 'hasFocus = true' if user is active and the window is in the background.
-        // Set 'hasFocus = false' if the user has been inactive (no mouse or keyboard activity) for 5 min. even when the window has focus.
-        function checkUserActive() {
-            var lastActive = isUserActive ? time() - isUserActive : 0;
-
-            // Throttle down when no mouse or keyboard activity for 5 min
-            if ( lastActive > 300000 && hasFocus )
-                 blurred();
-
-            if ( ! userActiveEvents ) {
-                $(document).on( 'mouseover.wp-heartbeat-active keyup.wp-heartbeat-active', function(){ userIsActive(); } );
+        /**
+         * Check for user activity
+         *
+         * Runs every 30 sec.
+         * Sets 'hasFocus = true' if user is active and the window is in the background.
+         * Set 'hasFocus = false' if the user has been inactive (no mouse or keyboard activity)
+         * for 5 min. even when the window has focus.
+         *
+         * @access private
+         *
+         * @return void
+         */
+        function checkUserActivity() {
+            var lastActive = settings.userActivity ? time() - settings.userActivity : 0;
+
+            if ( lastActive > 300000 && settings.hasFocus ) {
+                // Throttle down when no mouse or keyboard activity for 5 min
+                blurred();
+            }
+
+            if ( ! settings.userActivityEvents ) {
+                $document.on( 'mouseover.wp-heartbeat-active keyup.wp-heartbeat-active', function(){ userIsActive(); } );
 
                 $('iframe').each( function( i, frame ) {
-                    if ( ! isLocalFrame( frame ) )
+                    if ( ! isLocalFrame( frame ) ) {
                         return;
+                    }
 
                     $( frame.contentWindow ).on( 'mouseover.wp-heartbeat-active keyup.wp-heartbeat-active', function(){ userIsActive(); } );
                 });
 
-                userActiveEvents = true;
-            }
-        }
-
-        // Check for user activity every 30 seconds.
-        window.setInterval( function(){ checkUserActive(); }, 30000 );
-        $(document).ready( function() {
-            // Start one tick (15 sec) after DOM ready
-            running = true;
-            tick = time();
-            next();
-        });
-
-        this.hasFocus = function() {
-            return hasFocus;
-        };
+                settings.userActivityEvents = true;
+            }
+        }
+
+        // Public methods
+
+        /**
+         * Whether the window (or any local iframe in it) has focus, or the user is active
+         *
+         * @return bool
+         */
+        function hasFocus() {
+            return settings.hasFocus;
+        }
+
+        /**
+         * Whether there is a connection error
+         *
+         * @return bool
+         */
+        function hasConnectionError() {
+            return settings.connectionError;
+        }
+
+        /**
+         * Connect asap regardless of 'hasFocus'
+         *
+         * Will not open two concurrent connections. If a connection is in progress,
+         * will connect again immediately after the current connection completes.
+         *
+         * @return void
+         */
+        function connectNow() {
+            settings.lastTick = 0;
+            scheduleNextTick();
+        }
 
         /**
          * Get/Set the interval
          *
-         * When setting to 'fast', the interval is 5 sec. for the next 30 ticks (for 2 min and 30 sec).
+         * When setting to 'fast' or 5, by default interval is 5 sec. for the next 30 ticks (for 2 min and 30 sec).
+         * In this case the number of 'ticks' can be passed as second argument.
          * If the window doesn't have focus, the interval slows down to 2 min.
          *
-         * @param string speed Interval speed: 'fast' (5sec), 'standard' (15sec) default, 'slow' (60sec)
-         * @param string ticks Used with speed = 'fast', how many ticks before the speed reverts back
+         * @param mixed speed Interval: 'fast' or 5, 15, 30, 60
+         * @param string ticks Used with speed = 'fast' or 5, how many ticks before the interval reverts back
          * @return int Current interval in seconds
          */
-        this.interval = function( speed, ticks ) {
-            var reset, seconds;
-            ticks = parseInt( ticks, 10 ) || 30;
-            ticks = ticks < 1 || ticks > 30 ? 30 : ticks;
+        function setInterval( speed, ticks ) {
+            var interval, oldInerval = settings.tempInterval ? settings.tempInterval : settings.mainInterval;
 
             if ( speed ) {
                 switch ( speed ) {
                     case 'fast':
-                        seconds = 5;
-                        countdown = ticks;
+                    case 5:
+                        interval = 5000;
                         break;
-                    case 'slow':
-                        seconds = 60;
-                        countdown = 0;
+                    case 15:
+                        interval = 15000;
+                        break;
+                    case 30:
+                        interval = 30000;
+                        break;
+                    case 60:
+                        interval = 60000;
                         break;
                     case 'long-polling':
                         // Allow long polling, (experimental)
-                        interval = 0;
+                        settings.mainInterval = 0;
                         return 0;
                         break;
                     default:
-                        seconds = 15;
-                        countdown = 0;
-                }
-
-                // Reset when the new interval value is lower than the current one
-                reset = seconds * 1000 < interval;
-
-                if ( countdown > 0 ) {
-                    tempInterval = seconds * 1000;
+                        interval = settings.originalInterval;
+                }
+
+                if ( 5000 === interval ) {
+                    ticks = parseInt( ticks, 10 ) || 30;
+                    ticks = ticks < 1 || ticks > 30 ? 30 : ticks;
+
+                    settings.countdown = ticks;
+                    settings.tempInterval = interval;
                 } else {
-                    interval = seconds * 1000;
-                    tempInterval = 0;
-                }
-
-                if ( reset )
-                    next();
-            }
-
-            if ( ! hasFocus )
-                return 120;
-
-            return tempInterval ? tempInterval / 1000 : interval / 1000;
-        };
+                    settings.countdown = 0;
+                    settings.tempInterval = 0;
+                    settings.mainInterval = interval;
+                }
+
+                // Change the next connection time if new interval has been set.
+                // Will connect immediately if the time since the last connection
+                // is greater than the new interval.
+                if ( interval !== oldInerval ) {
+                    scheduleNextTick();
+                }
+            }
+
+            return settings.tempInterval ? settings.tempInterval / 1000 : settings.mainInterval / 1000;
+        }
 
         /**
          * Enqueue data to send with the next XHR
          *
-         * As the data is sent later, this function doesn't return the XHR response.
+         * As the data is send asynchronously, this function doesn't return the XHR response.
          * To see the response, use the custom jQuery event 'heartbeat-tick' on the document, example:
          *      $(document).on( 'heartbeat-tick.myname', function( event, data, textStatus, jqXHR ) {
@@ -429 +636 @@
          * $param string handle Unique handle for the data. The handle is used in PHP to receive the data.
          * $param mixed data The data to send.
-         * $param bool dont_overwrite Whether to overwrite existing data in the queue.
+         * $param bool noOverwrite Whether to overwrite existing data in the queue.
          * $return bool Whether the data was queued or not.
          */
-        this.enqueue = function( handle, data, dont_overwrite ) {
+        function enqueue( handle, data, noOverwrite ) {
             if ( handle ) {
-                if ( dont_overwrite && this.isQueued( handle ) )
+                if ( noOverwrite && this.isQueued( handle ) ) {
                     return false;
-
-                queue[handle] = data;
+                }
+
+                settings.queue[handle] = data;
                 return true;
             }
             return false;
-        };
+        }
 
         /**
@@ -449 +657 @@
          * $return bool Whether some data is queued with this handle
          */
-        this.isQueued = function( handle ) {
-            if ( handle )
-                return queue.hasOwnProperty( handle );
-        };
+        function isQueued( handle ) {
+            if ( handle ) {
+                return settings.queue.hasOwnProperty( handle );
+            }
+        }
 
         /**
@@ -460 +669 @@
          * $return void
          */
-        this.dequeue = function( handle ) {
-            if ( handle )
-                delete queue[handle];
-        };
+        function dequeue( handle ) {
+            if ( handle ) {
+                delete settings.queue[handle];
+            }
+        }
 
         /**
@@ -471 +681 @@
          * $return mixed The data or undefined
          */
-        this.getQueuedItem = function( handle ) {
-            if ( handle )
-                return this.isQueued( handle ) ? queue[handle] : undefined;
+        function getQueuedItem( handle ) {
+            if ( handle ) {
+                return this.isQueued( handle ) ? settings.queue[handle] : undefined;
+            }
+        }
+
+        initialize();
+
+        // Expose public methods
+        return {
+            hasFocus: hasFocus,
+            connectNow: connectNow,
+            setInterval: setInterval,
+            hasConnectionError: hasConnectionError,
+            enqueue: enqueue,
+            dequeue: dequeue,
+            isQueued: isQueued,
+            getQueuedItem: getQueuedItem
         };
     };
 
-    $.extend( Heartbeat.prototype, {
-        tick: function( data, textStatus, jqXHR ) {
-            $(document).trigger( 'heartbeat-tick', [data, textStatus, jqXHR] );
-        },
-        error: function( jqXHR, textStatus, error ) {
-            $(document).trigger( 'heartbeat-error', [jqXHR, textStatus, error] );
-        }
-    });
-
-    wp.heartbeat = new Heartbeat();
-
-}(jQuery));
+    // Ensure the global `wp` object exists.
+    window.wp = window.wp || {};
+    window.wp.heartbeat = new Heartbeat();
+
+}( jQuery, window ));