Changeset 7416

Timestamp:

02/22/07 23:10:01 (21 months ago)

Author:

BradNeuberg

Message:

Wired JavaScript? layer and Moxie into offline cache proxy API -- tested and works

Location:

trunk

Files:

• demos/storage/editor.html (modified) (1 diff)
• demos/storage/editor.js (modified) (3 diffs)
• dot/proxy/client.c (modified) (1 diff)
• dot/proxy/local.c (modified) (1 diff)
• dot/proxy/off.h (modified) (1 diff)
• src/off.js (modified) (5 diffs)
• src/off/ui.js (modified) (2 diffs)
• src/storage/browser.js (modified) (1 diff)

trunk/demos/storage/editor.html

@@ -10 +10 @@
                 var djConfig = 
                                                 { 
-                                                        isDebug: false, 
+                                                        isDebug: true, 
                                                         parseWidgets: false, 
                                                         searchIds: ["storageValue"] 

trunk/demos/storage/editor.js

@@ -13 +13 @@
 // set our application name
 dojo.off.ui.appName = "Moxie";
-
-// we aren't going to need a real offline cache for now;
-// we will just have our server return good HTTP/1.1
-// caching headers and rely on the browser's native cache
-dojo.off.requireOfflineCache = false;
 
 // add our list resources we need offline
@@ -368 +363 @@
                 var self = this;
                 dojo.sync.log.onCommand = function(command){
-                        dojo.debug("Moxie.onCommand="+command);
-                        dojo.debug("command.name="+command.name);
                         if(command.name == "save"){
                                 self._save(command.key, command.value);
@@ -377 +370 @@
                 // setup how we download our data from the server
                 dojo.sync.doDownload = function(){
-                        dojo.debug("Moxie.doDownload");
                         // actually download our data
                         self._downloadData();

trunk/dot/proxy/client.c

@@ -729 +729 @@
     HTTPConditionPtr condition;
     HTTPRangeRec range;
-
-        printf("httpClientRequest\n");
         
         referer = NULL;

trunk/dot/proxy/local.c

@@ -229 +229 @@
            isRunning, getVersion
     */
-        printf("results=%s\n", host_ptr);
         if(matchUrl("/polipo/offline?addOfflineHost", object)){
       status = addOfflineHost(host_ptr);

trunk/dot/proxy/off.h

@@ -25 +25 @@
     Example:
 
-      durableCacheCallback("isRunning", true);
+      window.offlineCacheCallback("isRunning", true);
 */
-#define OFF_JAVASCRIPT_CALLBACK "durableCacheCallback"
+#define OFF_JAVASCRIPT_CALLBACK "window.offlineCacheCallback"
 
 /*

trunk/src/off.js

@@ -71 +71 @@
         doNetworkChecking: true,
         
+        // hasOfflineCache: boolean
+        //  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, and 
+        //      dojo.off.requireOfflineCache is true, then an offline cache
+        //      will be installed
+        hasOfflineCache: null,
+        
+        _OFFLINE_CACHE_URL: "http://localhost:8123/polipo/offline?",
+        
         _onLoadListeners: new Array(),
         _storageLoaded: false,
         _pageLoaded: false,
-        
-        hasOfflineCache: function(){ /* boolean */
-                // summary: 
-                //      Returns whether we have an offline cache available
-                // description:
-                //      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, and 
-                //      dojo.off.requireOfflineCache is true, then an offline cache
-                //      will be installed
-        
-                // FIXME: Implement
-                return false;
-        },
         
         onOnline: function(){ /* void */
@@ -238 +234 @@
         },
         
+        addOfflineHost: function(resultsCallback /* Function(successful) */){
+                // summary:
+                //      Makes the this web application's host name, such as 
+                //  "sitepen.com", offline-enabled with a true offline cache.
+                // description:
+                //  If a true offline cache is available on this platform, this
+                //  means this hosts resources are made truly available
+                //  offline and will not disappear from the offline cache
+                //  as it might from a browser cache. The host name this
+                //  page was served from is the host that is used, such
+                //  as "sitepen.com".
+                // resultsCallback:
+                //  A Function that will be called with the results of this
+                //  add attempt; if it was successful, you will get true; if
+                //  not, you will receive false
+                if(this.requireOfflineCache == false){
+                        resultsCallback(true);
+                }
+                
+                if(this.hasOfflineCache != true){
+                        resultsCallback(false);
+                }
+                
+                this._talkToOfflineCache("addOfflineHost", resultsCallback);
+        },
+        
+        removeOfflineHost: function(resultsCallback /* Function(successful) */){
+                // summary:
+                //      Removes this web application's host name, such as "sitepen.com",
+                //  from being offline enabled.
+                // description:
+                //  If a true offline cache is available on this platform, this
+                //  means this hosts resources are made truly available
+                //  offline and will not disappear from the offline cache
+                //  as it might from a browser cache. The host name this
+                //  page was served from is the host that is used, such
+                //  as "sitepen.com".
+                // resultsCallback:
+                //  A Function that will be called with the results of this
+                //  remove attempt; if it was successful, you will get true; if
+                //  not, you will receive false
+                if(this.requireOfflineCache == false){
+                        resultsCallback(true);
+                }
+                
+                if(this.hasOfflineCache != true){
+                        resultsCallback(false);
+                }
+                
+                this._talkToOfflineCache("removeOfflineHost", resultsCallback);
+        },
+        
+        standardSaveHandler: function(status, isCoreSave, dataStore, item){
+                // summary:
+                //      Called by portions of the Dojo Offline framework
+                //      as a standard way to handle local save's; this method
+                //      is 'package private' and should not be used outside
+                //      of the Dojo Offline package.
+                if(status == dojo.storage.FAILED
+                        && isCoreSave == true){
+                        this.coreSaveFailed = true;
+                        this.enabled = false;   
+                }
+                
+                if(this.onSave){
+                        onSave(status, isCoreSave, dataStore, item);
+                }
+        },
+        
+        _checkOfflineCacheAvailable: function(finishedCallback){
+                var self = this;
+                
+                // is an true, offline cache running on this machine as a
+                // local web proxy distributed with DOT?
+                if(this.requireOfflineCache == false){
+                        self.hasOfflineCache = false;
+                        resultsCallback();
+                        return;
+                }
+                
+                // give the local proxy 200 milliseconds to respond
+                var timer = setTimeout(function(){
+                        self.hasOfflineCache = false;
+                        finishedCallback();
+                }, 200);
+                
+                this._talkToOfflineCache("isRunning", function(results){
+                        self.hasOfflineCache = true;
+                        window.clearTimeout(timer);
+                        finishedCallback();
+                });
+        },
+        
         _onLoad: function(){
                 //dojo.debug("dojo.off._onLoad");
@@ -249 +338 @@
                 // load framework data; when we are finished, continue
                 // initializing ourselves
+                this.load(dojo.lang.hitch(this, this._onFrameworkDataLoaded));
+        },
+        
+        _onFrameworkDataLoaded: function(){
+                // this method is part of our _onLoad series of startup tasks
+                
+                // see if we have an offline cache; when done, move
+                // on to the rest of our startup tasks
+                this._checkOfflineCacheAvailable(dojo.lang.hitch(this, this._onOfflineCacheChecked));
+        },
+        
+        _onOfflineCacheChecked: function(){
+                // this method is part of our _onLoad series of startup tasks
+                
+                // if we have an offline cache, try to add ourselves to this list of available
+                // offline web apps
+                if(this.hasOfflineCache == true){
+                        this.addOfflineHost(dojo.lang.hitch(this, this._finishStartingUp));
+                }else{
+                        this._finishStartingUp();
+                }
+        },
+        
+        _finishStartingUp: function(){
+                // this method is part of our _onLoad series of startup tasks
+                
+                // kick off a thread to check network status on
+                // a regular basis
+                this._startNetworkThread();
+
+                // try to go online
                 var self = this;
-                this.load(function(){
-                        // kick off a thread to check network status on
-                        // a regular basis
-                        self._startNetworkThread();
-                
-                        // try to go online
-                        self.goOnline(function(){
-                                // indicate we are ready to be used
-                                for(var i = 0; i < self._onLoadListeners.length; i++){
-                                        self._onLoadListeners[i]();
-                                }
-                        });
+                this.goOnline(function(){
+                        // indicate we are ready to be used
+                        for(var i = 0; i < self._onLoadListeners.length; i++){
+                                self._onLoadListeners[i]();
+                        }
                 });
         },
@@ -328 +441 @@
         },
         
-        standardSaveHandler: function(status, isCoreSave, dataStore, item){
-                // summary:
-                //      Called by portions of the Dojo Offline framework
-                //      as a standard way to handle local save's; this method
-                //      is 'package private' and should not be used outside
-                //      of the Dojo Offline package.
-                if(status == dojo.storage.FAILED
-                        && isCoreSave == true){
-                        this.coreSaveFailed = true;
-                        this.enabled = false;   
-                }
-                
-                if(this.onSave){
-                        onSave(status, isCoreSave, dataStore, item);
-                }
-        },
-        
         _startNetworkThread: function(){
                 // kick off a thread that does periodic
@@ -390 +486 @@
                 
                 return url;
+        },
+        
+        _talkToOfflineCache: function(methodName, resultsCallback){
+                var head = document.getElementsByTagName("head")[0];
+                var script = document.createElement("script");
+                var url = this._OFFLINE_CACHE_URL + methodName;
+                script.setAttribute("src", url);
+                window.offlineCacheCallback = function(name, results){
+                        if(name == "UnknownMethod"){
+                                dojo.raise("Programming error in dojo.off._talkToOfflineCache: " + name);
+                                return;
+                        }
+                        
+                        // avoid memory leaks on IE
+                        head = null;
+                        script = null;
+                        
+                        resultsCallback(results);
+                }
+                
+                head.appendChild(script);
         }
 });

trunk/src/off/ui.js

@@ -321 +321 @@
                 // check offline cache settings
                 if(dojo.off.requireOfflineCache == true
-                        && dojo.off.hasOfflineCache() == false){
+                        && dojo.off.hasOfflineCache == false){
                         this._needsOfflineCache();
                         return;
@@ -397 +397 @@
                         this.learnHowPath += "?appName=" + encodeURIComponent(this.appName)
                                                                         + "&requireOfflineCache=" + dojo.off.requireOfflineCache
-                                                                        + "&hasOfflineCache=" + dojo.off.hasOfflineCache()
+                                                                        + "&hasOfflineCache=" + dojo.off.hasOfflineCache
                                                                         + "&runLink=" + encodeURIComponent(this.runLink)
                                                                         + "&runLinkText=" + encodeURIComponent(this.runLinkText);

trunk/src/storage/browser.js

@@ -82 +82 @@
                 var self = this;
                 var storageListener = function(evt){
-                        dojo.debug("storage event, evt="+evt);
-                        
                         // remove any old storage event listener we might have added
                         // to the window on old put() requests; Firefox has a bug