| New file |
|---|
| 0,0 → 1,559 |
|---|
| if(!dojo._hasResource["dojox.off._common"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code. |
| dojo._hasResource["dojox.off._common"] = true; |
| dojo.provide("dojox.off._common"); |
| |
| dojo.require("dojox.storage"); |
| dojo.require("dojox.sql"); |
| dojo.require("dojox.off.sync"); |
| |
| // Author: Brad Neuberg, bkn3@columbia.edu, http://codinginparadise.org |
| |
| // summary: |
| // dojox.off is the main object for offline applications. |
| dojo.mixin(dojox.off, { |
| // isOnline: boolean |
| // true if we are online, false if not |
| isOnline: false, |
| |
| // NET_CHECK: int |
| // For advanced usage; most developers can ignore this. |
| // Time in seconds on how often we should check the status of the |
| // network with an automatic background timer. The current default |
| // is 5 seconds. |
| NET_CHECK: 5, |
| |
| // STORAGE_NAMESPACE: String |
| // For advanced usage; most developers can ignore this. |
| // The namespace we use to save core data into Dojo Storage. |
| STORAGE_NAMESPACE: "_dot", |
| |
| // enabled: boolean |
| // For advanced usage; most developers can ignore this. |
| // Whether offline ability is enabled or not. Defaults to true. |
| enabled: true, |
| |
| // availabilityURL: String |
| // For advanced usage; most developers can ignore this. |
| // The URL to check for site availability. We do a GET request on |
| // this URL to check for site availability. By default we check for a |
| // simple text file in src/off/network_check.txt that has one value |
| // it, the value '1'. |
| availabilityURL: dojo.moduleUrl("dojox", "off/network_check.txt"), |
| |
| // goingOnline: boolean |
| // For advanced usage; most developers can ignore this. |
| // True if we are attempting to go online, false otherwise |
| goingOnline: false, |
| |
| // coreOpFailed: boolean |
| // For advanced usage; most developers can ignore this. |
| // A flag set by the Dojo Offline framework that indicates that the |
| // user denied some operation that required the offline cache or an |
| // operation failed in some critical way that was unrecoverable. For |
| // example, if the offline cache is Google Gears and we try to get a |
| // Gears database, a popup window appears asking the user whether they |
| // will approve or deny this request. If the user denies the request, |
| // and we are doing some operation that is core to Dojo Offline, then |
| // we set this flag to 'true'. This flag causes a 'fail fast' |
| // condition, turning off offline ability. |
| coreOpFailed: false, |
| |
| // doNetChecking: boolean |
| // For advanced usage; most developers can ignore this. |
| // Whether to have a timing interval in the background doing automatic |
| // network checks at regular intervals; the length of time between |
| // checks is controlled by dojox.off.NET_CHECK. Defaults to true. |
| doNetChecking: true, |
| |
| // hasOfflineCache: boolean |
| // For advanced usage; most developers can ignore this. |
| // Determines if an offline cache is available or installed; an |
| // offline cache is a facility that can truely cache offline |
| // resources, such as JavaScript, HTML, etc. in such a way that they |
| // won't be removed from the cache inappropriately like a browser |
| // cache would. If this is false then an offline cache will be |
| // installed. Only Google Gears is currently supported as an offline |
| // cache. Future possible offline caches include Firefox 3. |
| hasOfflineCache: null, |
| |
| // browserRestart: boolean |
| // For advanced usage; most developers can ignore this. |
| // If true, the browser must be restarted to register the existence of |
| // a new host added offline (from a call to addHostOffline); if false, |
| // then nothing is needed. |
| browserRestart: false, |
| |
| _STORAGE_APP_NAME: window.location.href.replace(/[^0-9A-Za-z_]/g, "_"), |
| |
| _initializeCalled: false, |
| _storageLoaded: false, |
| _pageLoaded: false, |
| |
| onLoad: function(){ |
| // summary: |
| // Called when Dojo Offline can be used. |
| // description: |
| // Do a dojo.connect to this to know when you can |
| // start using Dojo Offline: |
| // dojo.connect(dojox.off, "onLoad", myFunc); |
| }, |
| |
| onNetwork: function(type){ |
| // summary: |
| // Called when our on- or offline- status changes. |
| // description: |
| // If we move online, then this method is called with the |
| // value "online". If we move offline, then this method is |
| // called with the value "offline". You can connect to this |
| // method to do add your own behavior: |
| // |
| // dojo.connect(dojox.off, "onNetwork", someFunc) |
| // |
| // Note that if you are using the default Dojo Offline UI |
| // widget that most of the on- and off-line notification |
| // and syncing is automatically handled and provided to the |
| // user. |
| // type: String |
| // Either "online" or "offline". |
| }, |
| |
| initialize: function(){ /* void */ |
| // summary: |
| // Called when a Dojo Offline-enabled application is finished |
| // configuring Dojo Offline, and is ready for Dojo Offline to |
| // initialize itself. |
| // description: |
| // When an application has finished filling out the variables Dojo |
| // Offline needs to work, such as dojox.off.ui.appName, it must |
| // this method to tell Dojo Offline to initialize itself. |
| |
| // Note: |
| // This method is needed for a rare edge case. In some conditions, |
| // especially if we are dealing with a compressed Dojo build, the |
| // entire Dojo Offline subsystem might initialize itself and be |
| // running even before the JavaScript for an application has had a |
| // chance to run and configure Dojo Offline, causing Dojo Offline |
| // to have incorrect initialization parameters for a given app, |
| // such as no value for dojox.off.ui.appName. This method is |
| // provided to prevent this scenario, to slightly 'slow down' Dojo |
| // Offline so it can be configured before running off and doing |
| // its thing. |
| |
| //console.debug("dojox.off.initialize"); |
| this._initializeCalled = true; |
| |
| if(this._storageLoaded && this._pageLoaded){ |
| this._onLoad(); |
| } |
| }, |
| |
| goOffline: function(){ /* void */ |
| // summary: |
| // For advanced usage; most developers can ignore this. |
| // Manually goes offline, away from the network. |
| if((dojox.off.sync.isSyncing)||(this.goingOnline)){ return; } |
| |
| this.goingOnline = false; |
| this.isOnline = false; |
| }, |
| |
| goOnline: function(callback){ /* void */ |
| // summary: |
| // For advanced usage; most developers can ignore this. |
| // Attempts to go online. |
| // description: |
| // Attempts to go online, making sure this web application's web |
| // site is available. 'callback' is called asychronously with the |
| // result of whether we were able to go online or not. |
| // callback: Function |
| // An optional callback function that will receive one argument: |
| // whether the site is available or not and is boolean. If this |
| // function is not present we call dojo.xoff.onOnline instead if |
| // we are able to go online. |
| |
| //console.debug("goOnline"); |
| |
| if(dojox.off.sync.isSyncing || dojox.off.goingOnline){ |
| return; |
| } |
| |
| this.goingOnline = true; |
| this.isOnline = false; |
| |
| // see if can reach our web application's web site |
| this._isSiteAvailable(callback); |
| }, |
| |
| onFrameworkEvent: function(type /* String */, saveData /* Object? */){ |
| // summary: |
| // For advanced usage; most developers can ignore this. |
| // A standard event handler that can be attached to to find out |
| // about low-level framework events. Most developers will not need to |
| // attach to this method; it is meant for low-level information |
| // that can be useful for updating offline user-interfaces in |
| // exceptional circumstances. The default Dojo Offline UI |
| // widget takes care of most of these situations. |
| // type: String |
| // The type of the event: |
| // |
| // * "offlineCacheInstalled" |
| // An event that is fired when a user |
| // has installed an offline cache after the page has been loaded. |
| // If a user didn't have an offline cache when the page loaded, a |
| // UI of some kind might have prompted them to download one. This |
| // method is called if they have downloaded and installed an |
| // offline cache so a UI can reinitialize itself to begin using |
| // this offline cache. |
| // * "coreOperationFailed" |
| // Fired when a core operation during interaction with the |
| // offline cache is denied by the user. Some offline caches, such |
| // as Google Gears, prompts the user to approve or deny caching |
| // files, using the database, and more. If the user denies a |
| // request that is core to Dojo Offline's operation, we set |
| // dojox.off.coreOpFailed to true and call this method for |
| // listeners that would like to respond some how to Dojo Offline |
| // 'failing fast'. |
| // * "save" |
| // Called whenever the framework saves data into persistent |
| // storage. This could be useful for providing save feedback |
| // or providing appropriate error feedback if saving fails |
| // due to a user not allowing the save to occur |
| // saveData: Object? |
| // If the type was 'save', then a saveData object is provided with |
| // further save information. This object has the following properties: |
| // |
| // * status - dojox.storage.SUCCESS, dojox.storage.PENDING, dojox.storage.FAILED |
| // Whether the save succeeded, whether it is pending based on a UI |
| // dialog asking the user for permission, or whether it failed. |
| // |
| // * isCoreSave - boolean |
| // If true, then this save was for a core piece of data necessary |
| // for the functioning of Dojo Offline. If false, then it is a |
| // piece of normal data being saved for offline access. Dojo |
| // Offline will 'fail fast' if some core piece of data could not |
| // be saved, automatically setting dojox.off.coreOpFailed to |
| // 'true' and dojox.off.enabled to 'false'. |
| // |
| // * key - String |
| // The key that we are attempting to persist |
| // |
| // * value - Object |
| // The object we are trying to persist |
| // |
| // * namespace - String |
| // The Dojo Storage namespace we are saving this key/value pair |
| // into, such as "default", "Documents", "Contacts", etc. |
| // Optional. |
| if(type == "save"){ |
| if(saveData.isCoreSave && (saveData.status == dojox.storage.FAILED)){ |
| dojox.off.coreOpFailed = true; |
| dojox.off.enabled = false; |
| |
| // FIXME: Stop the background network thread |
| dojox.off.onFrameworkEvent("coreOperationFailed"); |
| } |
| }else if(type == "coreOperationFailed"){ |
| dojox.off.coreOpFailed = true; |
| dojox.off.enabled = false; |
| // FIXME: Stop the background network thread |
| } |
| }, |
| |
| _checkOfflineCacheAvailable: function(callback){ |
| // is a true, offline cache running on this machine? |
| this.hasOfflineCache = dojo.isGears; |
| |
| callback(); |
| }, |
| |
| _onLoad: function(){ |
| //console.debug("dojox.off._onLoad"); |
| |
| // both local storage and the page are finished loading |
| |
| // cache the Dojo JavaScript -- just use the default dojo.js |
| // name for the most common scenario |
| // FIXME: TEST: Make sure syncing doesn't break if dojo.js |
| // can't be found, or report an error to developer |
| dojox.off.files.cache(dojo.moduleUrl("dojo", "dojo.js")); |
| |
| // pull in the files needed by Dojo |
| this._cacheDojoResources(); |
| |
| // FIXME: need to pull in the firebug lite files here! |
| // workaround or else we will get an error on page load |
| // from Dojo that it can't find 'console.debug' for optimized builds |
| // dojox.off.files.cache(djConfig.baseRelativePath + "src/debug.js"); |
| |
| // make sure that resources needed by all of our underlying |
| // Dojo Storage storage providers will be available |
| // offline |
| dojox.off.files.cache(dojox.storage.manager.getResourceList()); |
| |
| // slurp the page if the end-developer wants that |
| dojox.off.files._slurp(); |
| |
| // see if we have an offline cache; when done, move |
| // on to the rest of our startup tasks |
| this._checkOfflineCacheAvailable(dojo.hitch(this, "_onOfflineCacheChecked")); |
| }, |
| |
| _onOfflineCacheChecked: function(){ |
| // this method is part of our _onLoad series of startup tasks |
| |
| // if we have an offline cache, see if we have been added to the |
| // list of available offline web apps yet |
| if(this.hasOfflineCache && this.enabled){ |
| // load framework data; when we are finished, continue |
| // initializing ourselves |
| this._load(dojo.hitch(this, "_finishStartingUp")); |
| }else if(this.hasOfflineCache && !this.enabled){ |
| // we have an offline cache, but it is disabled for some reason |
| // perhaps due to the user denying a core operation |
| this._finishStartingUp(); |
| }else{ |
| this._keepCheckingUntilInstalled(); |
| } |
| }, |
| |
| _keepCheckingUntilInstalled: function(){ |
| // this method is part of our _onLoad series of startup tasks |
| |
| // kick off a background interval that keeps |
| // checking to see if an offline cache has been |
| // installed since this page loaded |
| |
| // FIXME: Gears: See if we are installed somehow after the |
| // page has been loaded |
| |
| // now continue starting up |
| this._finishStartingUp(); |
| }, |
| |
| _finishStartingUp: function(){ |
| //console.debug("dojox.off._finishStartingUp"); |
| |
| // this method is part of our _onLoad series of startup tasks |
| |
| if(!this.hasOfflineCache){ |
| this.onLoad(); |
| }else if(this.enabled){ |
| // kick off a thread to check network status on |
| // a regular basis |
| this._startNetworkThread(); |
| |
| // try to go online |
| this.goOnline(dojo.hitch(this, function(){ |
| //console.debug("Finished trying to go online"); |
| // indicate we are ready to be used |
| dojox.off.onLoad(); |
| })); |
| }else{ // we are disabled or a core operation failed |
| if(this.coreOpFailed){ |
| this.onFrameworkEvent("coreOperationFailed"); |
| }else{ |
| this.onLoad(); |
| } |
| } |
| }, |
| |
| _onPageLoad: function(){ |
| //console.debug("dojox.off._onPageLoad"); |
| this._pageLoaded = true; |
| |
| if(this._storageLoaded && this._initializeCalled){ |
| this._onLoad(); |
| } |
| }, |
| |
| _onStorageLoad: function(){ |
| //console.debug("dojox.off._onStorageLoad"); |
| this._storageLoaded = true; |
| |
| // were we able to initialize storage? if |
| // not, then this is a core operation, and |
| // let's indicate we will need to fail fast |
| if(!dojox.storage.manager.isAvailable() |
| && dojox.storage.manager.isInitialized()){ |
| this.coreOpFailed = true; |
| this.enabled = false; |
| } |
| |
| if(this._pageLoaded && this._initializeCalled){ |
| this._onLoad(); |
| } |
| }, |
| |
| _isSiteAvailable: function(callback){ |
| // summary: |
| // Determines if our web application's website is available. |
| // description: |
| // This method will asychronously determine if our web |
| // application's web site is available, which is a good proxy for |
| // network availability. The URL dojox.off.availabilityURL is |
| // used, which defaults to this site's domain name (ex: |
| // foobar.com). We check for dojox.off.AVAILABILITY_TIMEOUT (in |
| // seconds) and abort after that |
| // callback: Function |
| // An optional callback function that will receive one argument: |
| // whether the site is available or not and is boolean. If this |
| // function is not present we call dojox.off.onNetwork instead if we |
| // are able to go online. |
| dojo.xhrGet({ |
| url: this._getAvailabilityURL(), |
| handleAs: "text", |
| timeout: this.NET_CHECK * 1000, |
| error: dojo.hitch(this, function(err){ |
| //console.debug("dojox.off._isSiteAvailable.error: " + err); |
| this.goingOnline = false; |
| this.isOnline = false; |
| if(callback){ callback(false); } |
| }), |
| load: dojo.hitch(this, function(data){ |
| //console.debug("dojox.off._isSiteAvailable.load, data="+data); |
| this.goingOnline = false; |
| this.isOnline = true; |
| |
| if(callback){ callback(true); |
| }else{ this.onNetwork("online"); } |
| }) |
| }); |
| }, |
| |
| _startNetworkThread: function(){ |
| //console.debug("startNetworkThread"); |
| |
| // kick off a thread that does periodic |
| // checks on the status of the network |
| if(!this.doNetChecking){ |
| return; |
| } |
| |
| window.setInterval(dojo.hitch(this, function(){ |
| var d = dojo.xhrGet({ |
| url: this._getAvailabilityURL(), |
| handleAs: "text", |
| timeout: this.NET_CHECK * 1000, |
| error: dojo.hitch(this, |
| function(err){ |
| if(this.isOnline){ |
| this.isOnline = false; |
| |
| // FIXME: xhrGet() is not |
| // correctly calling abort |
| // on the XHR object when |
| // it times out; fix inside |
| // there instead of externally |
| // here |
| try{ |
| if(typeof d.ioArgs.xhr.abort == "function"){ |
| d.ioArgs.xhr.abort(); |
| } |
| }catch(e){} |
| |
| // if things fell in the middle of syncing, |
| // stop syncing |
| dojox.off.sync.isSyncing = false; |
| |
| this.onNetwork("offline"); |
| } |
| } |
| ), |
| load: dojo.hitch(this, |
| function(data){ |
| if(!this.isOnline){ |
| this.isOnline = true; |
| this.onNetwork("online"); |
| } |
| } |
| ) |
| }); |
| |
| }), this.NET_CHECK * 1000); |
| }, |
| |
| _getAvailabilityURL: function(){ |
| var url = this.availabilityURL.toString(); |
| |
| // bust the browser's cache to make sure we are really talking to |
| // the server |
| if(url.indexOf("?") == -1){ |
| url += "?"; |
| }else{ |
| url += "&"; |
| } |
| url += "browserbust=" + new Date().getTime(); |
| |
| return url; |
| }, |
| |
| _onOfflineCacheInstalled: function(){ |
| this.onFrameworkEvent("offlineCacheInstalled"); |
| }, |
| |
| _cacheDojoResources: function(){ |
| // if we are a non-optimized build, then the core Dojo bootstrap |
| // system was loaded as separate JavaScript files; |
| // add these to our offline cache list. these are |
| // loaded before the dojo.require() system exists |
| |
| // FIXME: create a better mechanism in the Dojo core to |
| // expose whether you are dealing with an optimized build; |
| // right now we just scan the SCRIPT tags attached to this |
| // page and see if there is one for _base/_loader/bootstrap.js |
| var isOptimizedBuild = true; |
| dojo.forEach(dojo.query("script"), function(i){ |
| var src = i.getAttribute("src"); |
| if(!src){ return; } |
| |
| if(src.indexOf("_base/_loader/bootstrap.js") != -1){ |
| isOptimizedBuild = false; |
| } |
| }); |
| |
| if(!isOptimizedBuild){ |
| dojox.off.files.cache(dojo.moduleUrl("dojo", "_base.js").uri); |
| dojox.off.files.cache(dojo.moduleUrl("dojo", "_base/_loader/loader.js").uri); |
| dojox.off.files.cache(dojo.moduleUrl("dojo", "_base/_loader/bootstrap.js").uri); |
| |
| // FIXME: pull in the host environment file in a more generic way |
| // for other host environments |
| dojox.off.files.cache(dojo.moduleUrl("dojo", "_base/_loader/hostenv_browser.js").uri); |
| } |
| |
| // add anything that was brought in with a |
| // dojo.require() that resulted in a JavaScript |
| // URL being fetched |
| |
| // FIXME: modify dojo/_base/_loader/loader.js to |
| // expose a public API to get this information |
| |
| for(var i = 0; i < dojo._loadedUrls.length; i++){ |
| dojox.off.files.cache(dojo._loadedUrls[i]); |
| } |
| |
| // FIXME: add the standard Dojo CSS file |
| }, |
| |
| _save: function(){ |
| // summary: |
| // Causes the Dojo Offline framework to save its configuration |
| // data into local storage. |
| }, |
| |
| _load: function(callback){ |
| // summary: |
| // Causes the Dojo Offline framework to load its configuration |
| // data from local storage |
| dojox.off.sync._load(callback); |
| } |
| }); |
| |
| |
| // wait until the storage system is finished loading |
| dojox.storage.manager.addOnLoad(dojo.hitch(dojox.off, "_onStorageLoad")); |
| |
| // wait until the page is finished loading |
| dojo.addOnLoad(dojox.off, "_onPageLoad"); |
| |
| } |