dojox/storage/AirEncryptedLocalStorageProvider.js

  • Provides:

    • dojox.storage.AirEncryptedLocalStorageProvider
  • Requires:

    • dojox.storage.manager in common
    • dojox.storage.Provider in common
  • dojox.storage.AirEncryptedLocalStorageProvider

    • type
      Function
    • chains:
      • dojox.storage.Provider: (prototype)
      • dojox.storage.Provider: (call)
    • summary
  • dojox.storage.AirEncryptedLocalStorageProvider.initialize

    • type
      Function
    • source: [view]
      dojo.provide("dojox.storage.AirEncryptedLocalStorageProvider");
      dojo.require("dojox.storage.manager");
      dojo.require("dojox.storage.Provider");


      if (dojo.isAIR) {
       (function(){

        
        if (!air) {
         var air = {};
        }
        air.ByteArray = window.runtime.flash.utils.ByteArray;
        air.EncryptedLocalStore = window.runtime.flash.data.EncryptedLocalStore,


        // summary:
        //  Storage provider that uses features in the Adobe AIR runtime to achieve
        //  permanent storage
        dojo.declare("dojox.storage.AirEncryptedLocalStorageProvider", [ dojox.storage.Provider ], {
         initialize: function(){
          // indicate that this storage provider is now loaded
          dojox.storage.manager.loaded();
    • summary
  • dojox.storage.AirEncryptedLocalStorageProvider.isAvailable

    • type
      Function
    • source: [view]
          return true;
    • summary
  • dojox.storage.AirEncryptedLocalStorageProvider._getItem

    • type
      Function
    • parameters:
      • key: (typeof )
    • source: [view]
          var storedValue = air.EncryptedLocalStore.getItem("__dojo_" + key);
          return storedValue ? storedValue.readUTFBytes(storedValue.length) : "";
    • summary
  • dojox.storage.AirEncryptedLocalStorageProvider._setItem

    • type
      Function
    • parameters:
      • key: (typeof )
      • value: (typeof )
    • source: [view]
          var bytes = new air.ByteArray();
          bytes.writeUTFBytes(value);
          air.EncryptedLocalStore.setItem("__dojo_" + key, bytes);
    • summary
  • dojox.storage.AirEncryptedLocalStorageProvider._removeItem

    • type
      Function
    • parameters:
      • key: (typeof )
    • source: [view]
          air.EncryptedLocalStore.removeItem("__dojo_" + key);
    • summary
  • dojox.storage.AirEncryptedLocalStorageProvider.put

    • type
      Function
    • parameters:
      • key: (typeof )
      • value: (typeof )
      • resultsHandler: (typeof )
      • namespace: (typeof )
    • source: [view]
          if(this.isValidKey(key) == false){
           throw new Error("Invalid key given: " + key);
          }
          namespace = namespace||this.DEFAULT_NAMESPACE;
          if(this.isValidKey(namespace) == false){
           throw new Error("Invalid namespace given: " + namespace);
          }

          
          // try to store the value
          try{
           var namespaces = this._getItem("namespaces")||'|';
           if(namespaces.indexOf('|'+namespace+'|')==-1){
            this._setItem("namespaces", namespaces + namespace + '|');
           }
           var keys = this._getItem(namespace + "_keys")||'|';
           if(keys.indexOf('|'+key+'|')==-1){
            this._setItem(namespace + "_keys", keys + key + '|');
           }
           this._setItem('_' + namespace + '_' + key, value);
          }catch(e){
           // indicate we failed
           console.debug("dojox.storage.AirEncryptedLocalStorageProvider.put:", e);
           resultsHandler(this.FAILED, key, e.toString(), namespace);
           return;
          }

          
          if(resultsHandler){
           resultsHandler(this.SUCCESS, key, null, namespace);
          }
    • summary
  • dojox.storage.AirEncryptedLocalStorageProvider.get

    • type
      Function
    • parameters:
      • key: (typeof )
      • namespace: (typeof )
    • source: [view]
          if(this.isValidKey(key) == false){
           throw new Error("Invalid key given: " + key);
          }
          namespace = namespace||this.DEFAULT_NAMESPACE;
          return this._getItem('_' + namespace + '_' + key);
    • summary
  • dojox.storage.AirEncryptedLocalStorageProvider.getNamespaces

    • type
      Function
    • source: [view]
          var results = [ this.DEFAULT_NAMESPACE ];
          var namespaces = (this._getItem("namespaces")||'|').split('|');
          for (var i=0;i     if(namespaces[i].length && namespaces[i] != this.DEFAULT_NAMESPACE){
            results.push(namespaces[i]);
           }
          }
          return results;
    • summary
  • dojox.storage.AirEncryptedLocalStorageProvider.getKeys

    • type
      Function
    • parameters:
      • namespace: (typeof )
    • source: [view]
          namespace = namespace||this.DEFAULT_NAMESPACE;
          if(this.isValidKey(namespace) == false){
           throw new Error("Invalid namespace given: " + namespace);
          }


          var results = [];
          var keys = (this._getItem(namespace + "_keys")||'|').split('|');
          for (var i=0;i     if (keys[i].length){
            results.push(keys[i]);
           }
          }
          return results;
    • summary
  • dojox.storage.AirEncryptedLocalStorageProvider.clear

    • type
      Function
    • parameters:
      • namespace: (typeof )
    • source: [view]
          if(this.isValidKey(namespace) == false){
           throw new Error("Invalid namespace given: " + namespace);
          }
          var namespaces = this._getItem("namespaces")||'|';
          if(namespaces.indexOf('|'+namespace+'|')!=-1){
           this._setItem("namespaces", namespaces.replace('|' + namespace + '|', '|'));
          }
          var keys = (this._getItem(namespace + "_keys")||'|').split('|');
          for (var i=0;i     if (keys[i].length){
            this._removeItem(namespace + "_" + keys[i]);
           }
          }
          this._removeItem(namespace + "_keys");
    • summary
  • dojox.storage.AirEncryptedLocalStorageProvider.remove

    • type
      Function
    • parameters:
      • key: (typeof )
      • namespace: (typeof )
    • source: [view]
          namespace = namespace||this.DEFAULT_NAMESPACE;

          
          var keys = this._getItem(namespace + "_keys")||'|';
          if(keys.indexOf('|'+key+'|')!=-1){
           this._setItem(namespace + "_keys", keys.replace('|' + key + '|', '|'));
          }
          this._removeItem('_' + namespace + '_' + key);
    • summary
  • dojox.storage.AirEncryptedLocalStorageProvider.putMultiple

    • type
      Function
    • parameters:
      • keys: (typeof )
      • values: (typeof )
      • resultsHandler: (typeof )
      • namespace: (typeof )
    • source: [view]
          if(this.isValidKeyArray(keys) === false
            || ! values instanceof Array
            || keys.length != values.length){
           throw new Error("Invalid arguments: keys = [" + keys + "], values = [" + values + "]");
          }

          
          if(namespace == null || typeof namespace == "undefined"){
           namespace = this.DEFAULT_NAMESPACE;
          }

       
          if(this.isValidKey(namespace) == false){
           throw new Error("Invalid namespace given: " + namespace);
          }

       
          this._statusHandler = resultsHandler;


          // try to store the value
          try{
           for(var i=0;i      this.put(keys[i], values[i], null, namespace);
           }
          }catch(e){
           // indicate we failed
           console.debug("dojox.storage.AirEncryptedLocalStorageProvider.putMultiple:", e);
           if(resultsHandler){
            resultsHandler(this.FAILED, keys, e.toString(), namespace);
           }
           return;
          }

          
          if(resultsHandler){
           resultsHandler(this.SUCCESS, keys, null);
          }
    • summary
  • dojox.storage.AirEncryptedLocalStorageProvider.getMultiple

    • type
      Function
    • parameters:
      • keys: (typeof )
      • namespace: (typeof )
    • source: [view]
          if(this.isValidKeyArray(keys) === false){
           throw new Error("Invalid key array given: " + keys);
          }

          
          if(namespace == null || typeof namespace == "undefined"){
           namespace = this.DEFAULT_NAMESPACE;
          }

          
          if(this.isValidKey(namespace) == false){
           throw new Error("Invalid namespace given: " + namespace);
          }

        
          var results = [];
          for(var i=0;i     results[i] = this.get(keys[i], namespace);
          }
          return results;
    • summary
  • dojox.storage.AirEncryptedLocalStorageProvider.removeMultiple

    • type
      Function
    • parameters:
      • keys: (typeof )
      • namespace: (typeof )
    • source: [view]
          namespace = namespace||this.DEFAULT_NAMESPACE;
          for(var i=0;i     this.remove(keys[i], namespace);
          }
    • summary
  • dojox.storage.AirEncryptedLocalStorageProvider.isPermanent

    • type
      Function
    • source: [view]
         isPermanent: function(){ return true;
    • summary
  • dojox.storage.AirEncryptedLocalStorageProvider.getMaximumSize

    • type
      Function
    • source: [view]
         getMaximumSize: function(){ return this.SIZE_NO_LIMIT;
    • summary
  • dojox.storage.AirEncryptedLocalStorageProvider.hasSettingsUI

    • type
      Function
    • source: [view]
         hasSettingsUI: function(){ return false;
    • summary
  • dojox.storage.AirEncryptedLocalStorageProvider.showSettingsUI

    • type
      Function
    • source: [view]
          throw new Error(this.declaredClass + " does not support a storage settings user-interface");
    • summary
  • dojox.storage.AirEncryptedLocalStorageProvider.hideSettingsUI

    • type
      Function
    • source: [view]
          throw new Error(this.declaredClass + " does not support a storage settings user-interface");
    • summary
  • dojox.storage.AirEncryptedLocalStorageProvider._statusHandler

    • summary
  • air.ByteArray

    • summary
  • air.EncryptedLocalStore

    • summary
  • dojox.storage

    • type
      Object
    • summary
  • dojox

    • type
      Object
    • summary