source: Dev/trunk/src/client/dojox/storage/Storage.as

import DojoExternalInterface;

class Storage{
        public static var SUCCESS = "success";
        public static var FAILED = "failed";
        public static var PENDING = "pending";
        
        //      Wait the following number of milliseconds before flushing
        public static var FLUSH_DELAY_DEFAULT = 500;
        
        public var flush_delay;
        public var so;
        public var timer;
        
        private var _NAMESPACE_KEY = "allNamespaces";
        
        public function Storage(){
                flush_delay = Storage.FLUSH_DELAY_DEFAULT;
        
                DojoExternalInterface.initialize();
                DojoExternalInterface.addCallback("put", this, put);
                DojoExternalInterface.addCallback("putMultiple", this, putMultiple);
                DojoExternalInterface.addCallback("get", this, get);
                DojoExternalInterface.addCallback("getMultiple", this, getMultiple);
                DojoExternalInterface.addCallback("showSettings", this, showSettings);
                DojoExternalInterface.addCallback("clear", this, clear);
                DojoExternalInterface.addCallback("getKeys", this, getKeys);
                DojoExternalInterface.addCallback("getNamespaces", this, getNamespaces);
                DojoExternalInterface.addCallback("remove", this, remove);
                DojoExternalInterface.addCallback("removeMultiple", this, removeMultiple);
                DojoExternalInterface.addCallback("flush", this, flush);
                DojoExternalInterface.addCallback("setFlushDelay", this, setFlushDelay);
                DojoExternalInterface.addCallback("getFlushDelay", this, getFlushDelay);
                DojoExternalInterface.loaded();
                
                // preload the System Settings finished button movie for offline
                // access so it is in the cache
                _root.createEmptyMovieClip("_settingsBackground", 1);
                _root._settingsBackground.loadMovie(DojoExternalInterface.dojoPath 
                                                                                                                                                                + "../dojox/storage/storage_dialog.swf");
        }

  //  FIXME: Whoever added this Flush code did not document why it
  //  exists. Please also put your name and a bug number so I know 
  //  who to contact. -- Brad Neuberg
        
        //      Set a new value for the flush delay timer.
        //      Possible values:
        //        0 : Perform the flush synchronously after each "put" request
        //      > 0 : Wait until 'newDelay' ms have passed without any "put" request to flush
        //       -1 : Do not automatically flush
        public function setFlushDelay(newDelay){
                flush_delay = Number(newDelay);
        }
        
        public function getFlushDelay(){
                return String(flush_delay);
        }
        
        public function flush(namespace){
                if(timer){
                        _global.clearTimeout(timer);
                        delete timer;
                }
        
                var so = SharedObject.getLocal(namespace);
                var flushResults = so.flush();

                // return results of this command to JavaScript
                var statusResults;
                if(flushResults == true){
                        statusResults = Storage.SUCCESS;
                }else if(flushResults == "pending"){
                        statusResults = Storage.PENDING;
                }else{
                        statusResults = Storage.FAILED;
                }
                
                DojoExternalInterface.call("dojox.storage._onStatus", statusResults, 
                                            null, namespace);
        }

        public function put(keyName, keyValue, namespace){
                // Get the SharedObject for these values and save it
                so = SharedObject.getLocal(namespace);
                
                //  Save the key and value
                so.data[keyName] = keyValue;
                
                // Save the namespace
                // FIXME: Tie this into the flush/no-flush stuff below; right now
                // we immediately write out this namespace. -- Brad Neuberg
    addNamespace(namespace, keyName);

                //      Do all the flush/no-flush stuff
                var keyNames = new Array(); 
                keyNames[0] = keyName;
                postWrite(so, keyNames, namespace);
        }
        
        public function putMultiple(metaKey, metaValue, metaLengths, namespace){
                // Get the SharedObject for these values and save it
                so = SharedObject.getLocal(namespace);
                
                //      Create array of keys and value lengths
                var keys = metaKey.split(",");
                var lengths = metaLengths.split(",");
                
                //      Loop through the array and write the values
                for(var i = 0; i < keys.length; i++){
                        so.data[keys[i]] = metaValue.slice(0,lengths[i]);
                        metaValue = metaValue.slice(lengths[i]);
                }
                
                // Save the namespace
                // FIXME: Tie this into the flush/no-flush stuff below; right now
                // we immediately write out this namespace. -- Brad Neuberg
    addNamespace(namespace, null);
                
                //      Do all the flush/no-flush stuff
                postWrite(so, keys, namespace);
        }

        public function postWrite(so, keyNames, namespace){
                //      TODO: Review all this 'handler' stuff. In particular, the flush 
                //  could now be with keys pending from several different requests, not 
                //  only the ones passed in this method call

                // prepare a storage status handler
                var self = this;
                so.onStatus = function(infoObject:Object){
                        //trace("onStatus, infoObject="+infoObject.code);
                        
                        // delete the data value if the request was denied
                        if(infoObject.code == "SharedObject.Flush.Failed"){
                                for(var i=0;i<keyNames.length;i++){
                                        delete self.so.data[keyNames[i]];
                                }
                        }
                        
                        var statusResults;
                        if(infoObject.code == "SharedObject.Flush.Failed"){
                                statusResults = Storage.FAILED;
                        }else if(infoObject.code == "SharedObject.Flush.Pending"){
                                statusResults = Storage.PENDING;
                        }else if(infoObject.code == "SharedObject.Flush.Success"){
                                // if we have succeeded saving our value, see if we
                                // need to update our list of namespaces
                                if(self.hasNamespace(namespace) == true){
                                        statusResults = Storage.SUCCESS;
                                }else{
                                        // we have a new namespace we must store
                                        self.addNamespace(namespace, keyNames[0]);
                                        return;
                                }
                        }
                        //trace("onStatus, statusResults="+statusResults);
                        
                        // give the status results to JavaScript
                        DojoExternalInterface.call("dojox.storage._onStatus", statusResults, 
                                                    keyNames[0], namespace);
                }
                
                //      Clear any pending flush timers
                if(timer){
                        _global.clearTimeout(timer);
                }
                
                //      If we have a flush delay set, set a timer for its execution
                if(flush_delay > 0){
                        timer = _global.setTimeout(flush, flush_delay, namespace);
                //      With a flush_delay value of 0, execute the flush request synchronously
                }else if(flush_delay == 0){
                        flush(namespace);
                }
                //      Otherwise just don't flush - will be probably be flushed manually
        }

        public function get(keyName, namespace){
                // Get the SharedObject for these values and save it
                so = SharedObject.getLocal(namespace);
                var results = so.data[keyName];
                
                return results;
        }
        
        //      Returns an array with the contents of each key value on the metaKeys array
        public function getMultiple(metaKeys, namespace){
                //      get the storage object
                so = SharedObject.getLocal(namespace);
                
                //      Create array of keys to read
                var keys = metaKeys.split(",");
                var results = new Array();
                
                //      Read from storage into results array
                for(var i = 0;i < keys.length;i++){
                        var val = so.data[keys[i]];
                        val = val.split("\\").join("\\\\");
                        val = val.split('"').join('\\"');
                        results.push( val);
                }
                        
                //      Make the results array into a string
                var metaResults = '["' + results.join('","') + '"]';
                
                return metaResults;
        }       
        
        public function showSettings(){
                // Show the configuration options for the Flash player, opened to the
                // section for local storage controls (pane 1)
                System.showSettings(1);
                
                // there is no way we can intercept when the Close button is pressed, allowing us
                // to hide the Flash dialog. Instead, we need to load a movie in the
                // background that we can show a close button on.
                _root.createEmptyMovieClip("_settingsBackground", 1);
                _root._settingsBackground.loadMovie(DojoExternalInterface.dojoPath 
                                                                                                                                                                + "../dojox/storage/storage_dialog.swf");
        }
        
        public function clear(namespace){
                so = SharedObject.getLocal(namespace);
                so.clear();
                so.flush();
                
                // remove this namespace entry now
                removeNamespace(namespace);
        }
        
        public function getKeys(namespace) : String{
                // Returns a list of the available keys in this namespace
                
                // get the storage object
                so = SharedObject.getLocal(namespace);
                // get all of the keys
                var results = [];
                for(var i in so.data){
                        results.push(i);        
                }
                
                // remove our key that records our list of namespaces
                for(var i = 0; i < results.length; i++){
                        if(results[i] == _NAMESPACE_KEY){
                                results.splice(i, 1);
                                break;
                        }
                }
                
                // a bug in ExternalInterface transforms Arrays into
                // Strings, so we can't use those here! -- BradNeuberg
                results = results.join(",");
                
                return results;
        }
        
        public function getNamespaces() : String{
                var allNamespaces = SharedObject.getLocal(_NAMESPACE_KEY);
                var results = [];
                
                for(var i in allNamespaces.data){
                        results.push(i);
                }
                
                // a bug in ExternalInterface transforms Arrays into
                // Strings, so we can use those here! -- BradNeuberg
                results = results.join(",");
                
                return results;
        }
        
        public function remove(keyName, namespace){
                // Removes a key

                // get the storage object
                so = SharedObject.getLocal(namespace);
                
                // delete this value
                delete so.data[keyName];
                
                // save the changes
                so.flush();
                
                // see if we are the last entry for this namespace
                var availableKeys = getKeys(namespace);
                if(availableKeys == ""){
                        // we are empty
                        removeNamespace(namespace);
                }
        }
        
        //      Removes all the values for each keys on the metaKeys array
        public function removeMultiple(metaKeys, namespace){            
                //      get the storage object
                so = SharedObject.getLocal(namespace);
                
                //      Create array of keys to read
                var keys = metaKeys.split(",");
                var results = new Array();

                //      Delete elements
                for(var i=0;i<keys.length;i++){
                        delete so.data[keys[i]];
                }

                // see if there are no more entries for this namespace
                var availableKeys = getKeys(namespace);
                if(availableKeys == ""){
                        // we are empty
                        removeNamespace(namespace);
                }
        }
        
        private function hasNamespace(namespace):Boolean{
                // Get the SharedObject for the namespace list
                var allNamespaces = SharedObject.getLocal(_NAMESPACE_KEY);
                
                var results = false;
                for(var i in allNamespaces.data){
                        if(i == namespace){
                                results = true;
                                break;
                        }
                }
                
                return results;
        }
        
        // FIXME: This code has gotten ugly -- refactor
        private function addNamespace(namespace, keyName){
                if(hasNamespace(namespace) == true){
                        return;
                }
                
                // Get the SharedObject for the namespace list
                var allNamespaces = SharedObject.getLocal(_NAMESPACE_KEY);
                
                // prepare a storage status handler if the keyName is
                // not null
                if(keyName != null && typeof keyName != "undefined"){
                        var self = this;
                        allNamespaces.onStatus = function(infoObject:Object){
                                // delete the data value if the request was denied
                                if(infoObject.code == "SharedObject.Flush.Failed"){
                                        delete self.so.data[keyName];
                                }
                                
                                var statusResults;
                                if(infoObject.code == "SharedObject.Flush.Failed"){
                                        statusResults = Storage.FAILED;
                                }else if(infoObject.code == "SharedObject.Flush.Pending"){
                                        statusResults = Storage.PENDING;
                                }else if(infoObject.code == "SharedObject.Flush.Success"){
                                        statusResults = Storage.SUCCESS;
                                }
                                
                                // give the status results to JavaScript
                                DojoExternalInterface.call("dojox.storage._onStatus", statusResults, 
                                                            keyName, namespace);
                        }
                }
                
                // save the namespace list
                allNamespaces.data[namespace] = true;
                var flushResults = allNamespaces.flush();
                
                // return results of this command to JavaScript
                if(keyName != null && typeof keyName != "undefined"){
                        var statusResults;
                        if(flushResults == true){
                                statusResults = Storage.SUCCESS;
                        }else if(flushResults == "pending"){
                                statusResults = Storage.PENDING;
                        }else{
                                statusResults = Storage.FAILED;
                        }
                        
                        DojoExternalInterface.call("dojox.storage._onStatus", statusResults, 
                                                    keyName, namespace);
                }
        }
        
        // FIXME: This code has gotten ugly -- refactor
        private function removeNamespace(namespace){
                if(hasNamespace(namespace) == false){
                        return;
                }
                
                // try to save the namespace list; don't have a return
                // callback; if we fail on this, the worst that will happen
                // is that we have a spurious namespace entry
                var allNamespaces = SharedObject.getLocal(_NAMESPACE_KEY);
                delete allNamespaces.data[namespace];
                allNamespaces.flush();
        }

        static function main(mc){
                _root.app = new Storage(); 
        }
}