Subversion Repositories Applications.papyrus

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");

}