| New file |
|---|
| 0,0 → 1,251 |
|---|
| if(!dojo._hasResource["dojox.storage.manager"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code. |
| dojo._hasResource["dojox.storage.manager"] = true; |
| dojo.provide("dojox.storage.manager"); |
| //dojo.require("dojo.AdapterRegistry"); |
| // FIXME: refactor this to use an AdapterRegistry |
| |
| dojox.storage.manager = new function(){ |
| // summary: A singleton class in charge of the dojox.storage system |
| // description: |
| // Initializes the storage systems and figures out the best available |
| // storage options on this platform. |
| |
| // currentProvider: Object |
| // The storage provider that was automagically chosen to do storage |
| // on this platform, such as dojox.storage.FlashStorageProvider. |
| this.currentProvider = null; |
| |
| // available: Boolean |
| // Whether storage of some kind is available. |
| this.available = false; |
| |
| this._initialized = false; |
| |
| this._providers = []; |
| this._onLoadListeners = []; |
| |
| this.initialize = function(){ |
| // summary: |
| // Initializes the storage system and autodetects the best storage |
| // provider we can provide on this platform |
| this.autodetect(); |
| }; |
| |
| this.register = function(/*string*/ name, /*Object*/ instance){ |
| // summary: |
| // Registers the existence of a new storage provider; used by |
| // subclasses to inform the manager of their existence. The |
| // storage manager will select storage providers based on |
| // their ordering, so the order in which you call this method |
| // matters. |
| // name: |
| // The full class name of this provider, such as |
| // "dojox.storage.FlashStorageProvider". |
| // instance: |
| // An instance of this provider, which we will use to call |
| // isAvailable() on. |
| this._providers[this._providers.length] = instance; //FIXME: push? |
| this._providers[name] = instance; // FIXME: this._providers is an array, not a hash |
| }; |
| |
| this.setProvider = function(storageClass){ |
| // summary: |
| // Instructs the storageManager to use the given storage class for |
| // all storage requests. |
| // description: |
| // Example- |
| // dojox.storage.setProvider( |
| // dojox.storage.IEStorageProvider) |
| |
| }; |
| |
| this.autodetect = function(){ |
| // summary: |
| // Autodetects the best possible persistent storage provider |
| // available on this platform. |
| |
| //console.debug("dojox.storage.manager.autodetect"); |
| |
| if(this._initialized){ // already finished |
| //console.debug("dojox.storage.manager already initialized; returning"); |
| return; |
| } |
| |
| // a flag to force the storage manager to use a particular |
| // storage provider type, such as |
| // djConfig = {forceStorageProvider: "dojox.storage.WhatWGStorageProvider"}; |
| var forceProvider = djConfig["forceStorageProvider"]||false; |
| |
| // go through each provider, seeing if it can be used |
| var providerToUse; |
| //FIXME: use dojo.some |
| for(var i = 0; i < this._providers.length; i++){ |
| providerToUse = this._providers[i]; |
| if(forceProvider == providerToUse.declaredClass){ |
| // still call isAvailable for this provider, since this helps some |
| // providers internally figure out if they are available |
| // FIXME: This should be refactored since it is non-intuitive |
| // that isAvailable() would initialize some state |
| providerToUse.isAvailable(); |
| break; |
| }else if(providerToUse.isAvailable()){ |
| break; |
| } |
| } |
| |
| if(!providerToUse){ // no provider available |
| this._initialized = true; |
| this.available = false; |
| this.currentProvider = null; |
| console.warn("No storage provider found for this platform"); |
| this.loaded(); |
| return; |
| } |
| |
| // create this provider and mix in it's properties |
| // so that developers can do dojox.storage.put rather |
| // than dojox.storage.currentProvider.put, for example |
| this.currentProvider = providerToUse; |
| dojo.mixin(dojox.storage, this.currentProvider); |
| |
| // have the provider initialize itself |
| dojox.storage.initialize(); |
| |
| this._initialized = true; |
| this.available = true; |
| }; |
| |
| this.isAvailable = function(){ /*Boolean*/ |
| // summary: Returns whether any storage options are available. |
| return this.available; |
| }; |
| |
| this.addOnLoad = function(func){ /* void */ |
| // summary: |
| // Adds an onload listener to know when Dojo Offline can be used. |
| // description: |
| // Adds a listener to know when Dojo Offline can be used. This |
| // ensures that the Dojo Offline framework is loaded and that the |
| // local dojox.storage system is ready to be used. This method is |
| // useful if you don't want to have a dependency on Dojo Events |
| // when using dojox.storage. |
| // func: Function |
| // A function to call when Dojo Offline is ready to go |
| this._onLoadListeners.push(func); |
| |
| if(this.isInitialized()){ |
| this._fireLoaded(); |
| } |
| }; |
| |
| this.removeOnLoad = function(func){ /* void */ |
| // summary: Removes the given onLoad listener |
| for(var i = 0; i < this._onLoadListeners.length; i++){ |
| if(func == this._onLoadListeners[i]){ |
| this._onLoadListeners = this._onLoadListeners.splice(i, 1); |
| break; |
| } |
| } |
| }; |
| |
| this.isInitialized = function(){ /*Boolean*/ |
| // summary: |
| // Returns whether the storage system is initialized and ready to |
| // be used. |
| |
| // FIXME: This should REALLY not be in here, but it fixes a tricky |
| // Flash timing bug |
| if(this.currentProvider != null |
| && this.currentProvider.declaredClass == "dojox.storage.FlashStorageProvider" |
| && dojox.flash.ready == false){ |
| return false; |
| }else{ |
| return this._initialized; |
| } |
| }; |
| |
| this.supportsProvider = function(/*string*/ storageClass){ /* Boolean */ |
| // summary: Determines if this platform supports the given storage provider. |
| // description: |
| // Example- |
| // dojox.storage.manager.supportsProvider( |
| // "dojox.storage.InternetExplorerStorageProvider"); |
| |
| // construct this class dynamically |
| try{ |
| // dynamically call the given providers class level isAvailable() |
| // method |
| var provider = eval("new " + storageClass + "()"); |
| var results = provider.isAvailable(); |
| if(!results){ return false; } |
| return results; |
| }catch(e){ |
| return false; |
| } |
| }; |
| |
| this.getProvider = function(){ /* Object */ |
| // summary: Gets the current provider |
| return this.currentProvider; |
| }; |
| |
| this.loaded = function(){ |
| // summary: |
| // The storage provider should call this method when it is loaded |
| // and ready to be used. Clients who will use the provider will |
| // connect to this method to know when they can use the storage |
| // system. You can either use dojo.connect to connect to this |
| // function, or can use dojox.storage.manager.addOnLoad() to add |
| // a listener that does not depend on the dojo.event package. |
| // description: |
| // Example 1- |
| // if(dojox.storage.manager.isInitialized() == false){ |
| // dojo.connect(dojox.storage.manager, "loaded", TestStorage, "initialize"); |
| // }else{ |
| // dojo.connect(dojo, "loaded", TestStorage, "initialize"); |
| // } |
| // Example 2- |
| // dojox.storage.manager.addOnLoad(someFunction); |
| |
| |
| // FIXME: we should just provide a Deferred for this. That way you |
| // don't care when this happens or has happened. Deferreds are in Base |
| this._fireLoaded(); |
| }; |
| |
| this._fireLoaded = function(){ |
| //console.debug("dojox.storage.manager._fireLoaded"); |
| |
| dojo.forEach(this._onLoadListeners, function(i){ |
| try{ |
| i(); |
| }catch(e){ console.debug(e); } |
| }); |
| }; |
| |
| this.getResourceList = function(){ |
| // summary: |
| // Returns a list of whatever resources are necessary for storage |
| // providers to work. |
| // description: |
| // This will return all files needed by all storage providers for |
| // this particular environment type. For example, if we are in the |
| // browser environment, then this will return the hidden SWF files |
| // needed by the FlashStorageProvider, even if we don't need them |
| // for the particular browser we are working within. This is meant |
| // to faciliate Dojo Offline, which must retrieve all resources we |
| // need offline into the offline cache -- we retrieve everything |
| // needed, in case another browser that requires different storage |
| // mechanisms hits the local offline cache. For example, if we |
| // were to sync against Dojo Offline on Firefox 2, then we would |
| // not grab the FlashStorageProvider resources needed for Safari. |
| var results = []; |
| dojo.forEach(dojox.storage.manager._providers, function(currentProvider){ |
| results = results.concat(currentProvider.getResourceList()); |
| }); |
| |
| return results; |
| } |
| }; |
| |
| } |