home *** CD-ROM | disk | FTP | other *** search
/ PC World 2006 December / PCWorld_2006-12_cd.bin / komunikace / netscape / nsb-install-8-1-2.exe / chrome / browser.jar / content / browser / featureDiscovery.js < prev    next >
Text File  |  2006-01-06  |  13KB  |  375 lines
  1. var featureDiscovery = {
  2.  
  3.     // Set this to false to disable debug output
  4.     FD_DEBUG : false,
  5.  
  6.     // Constants
  7.     MAX_NUMBER_FEATURES         : 256,   // maximum number of feature discovery urls in .dat file
  8.     FEATURE_DISCOVERY_FILE     : "featureDiscovery.dat",
  9.     
  10.     // Prefs
  11.     PREF_LASTUPDATEDATE         : "browser.featurediscovery.lastupdatedate",
  12.     PREF_UPDATE_URL                 : "browser.featurediscovery.updateurl",
  13.     PREF_UPDATE_INTERVAL         : "browser.featurediscovery.updateinterval",
  14.     
  15.     // Pref types
  16.     PREF_TYPE_INVALID                : 0,   // Invalid
  17.     PREF_TYPE_STRING                : 32,  // String
  18.     PREF_TYPE_INT                        : 64,  // Integer
  19.     PREF_TYPE_BOOL                    : 128, // Boolean
  20.  
  21.     // File open flags (from prio.h)
  22.     PR_RDONLY   : 1,
  23.     PR_WRONLY   : 2,
  24.     PR_TRUNCATE : 4,
  25.  
  26.     // Globals
  27.     datFileDir                 : null,
  28.     ioService                 : null,
  29.     remoteupdatefile     : null,
  30.     featureList             : null,
  31.     prefService             : null,
  32.     uriservice                : null,
  33.  
  34.     Init : function() {
  35.         this.debug('Init()');
  36.         
  37.         // Get the working directory based on DefRt
  38.         // Data file stored in /dist/bin/defaults/featurediscovery.dat (for the debug build)
  39.  
  40.         if (!this.datFileDir) {
  41.             this.datFileDir = Components.classes["@mozilla.org/file/directory_service;1"]
  42.                                         .getService(Components.interfaces.nsIProperties)
  43.                                         .get("DefRt", Components.interfaces.nsILocalFile);
  44.         }
  45.         this.debug(' datFileDir: '+this.datFileDir.path);
  46.                 
  47.         /*
  48.                 const IPS = Components.interfaces.nsIPromptService;
  49.                 var ps = Components.classes["@mozilla.org/embedcomp/prompt-service;1"]
  50.                               .getService(IPS);
  51.                 ps.alert(window,"Feature Discovery", "The feature discovery path is " + this.datFileDir.path );
  52.         */
  53.  
  54.         this.ReadFeatureDiscovery();
  55.         
  56.         // MERC - rfransen - begin update featurediscovery.dat process.
  57.         
  58.         // We need to work with the browser preferences, so let's get a reference
  59.         // to the preference service.
  60.         prefService = Components.classes["@mozilla.org/preferences-service;1"]
  61.                              .getService(Components.interfaces.nsIPrefBranch);
  62.                              
  63.       // And we need to the uri service
  64.       uriservice = Components.classes["@mozilla.org/network/standard-url;1"]
  65.                   .createInstance(Components.interfaces.nsIURI);
  66.       
  67.       if (prefService)
  68.       {
  69.           // We should first check to see if our prefs our at all valid...
  70.             if ((prefService.getPrefType(this.PREF_LASTUPDATEDATE) == this.PREF_TYPE_INT ) &&
  71.                     (prefService.getPrefType(this.PREF_UPDATE_INTERVAL) == this.PREF_TYPE_INT ) &&
  72.                     (prefService.getPrefType(this.PREF_UPDATE_URL) == this.PREF_TYPE_STRING ))
  73.             {
  74.                 // Ok, the first thing we should do is see if it is time go fetch an updated .dat file
  75.                 // Right, so how about we see the last we downloaded the File?
  76.                 var lastdownloadtime = prefService.getIntPref(this.PREF_LASTUPDATEDATE);
  77.                 this.debug("lastdownloadtime: " + lastdownloadtime);
  78.                 // Right, now we know when we last updated this file, so now what?
  79.                 // We should determine the update frequency
  80.                 var updatefrequency = prefService.getIntPref(this.PREF_UPDATE_INTERVAL);
  81.                 this.debug("updatefrequency: " + updatefrequency);
  82.                 // Ok, so have we passed the update interval?
  83.                 var updatedifferential = this.NowInSeconds() > (lastdownloadtime + updatefrequency);
  84.                 this.debug("updatedifferential: " + updatedifferential);
  85.                 // if uodatedifferential is true, let's party, otherwise, not time to download
  86.                 if (updatedifferential)
  87.                 {
  88.                     // It is time to get the new .dat file, let's get it!
  89.                     this.FetchNewDatFile();
  90.                 }
  91.                 else
  92.                 {
  93.                     this.debug("No new .dat file to grab.  Aborting Fetch.");
  94.                 }
  95.             }
  96.             else
  97.             {
  98.                 // Uh oh, some of our pref's are not valid, let's dump and bail
  99.                 try
  100.                 {
  101.                 this.debug("lastupdatedate : " + prefService.getPrefType(this.PREF_LASTUPDATEDATE) + "\n" +
  102.                                      "updateinterval : " + prefService.getPrefType(this.PREF_UPDATE_INTERVAL) + "\n" +
  103.                                      "update url     : " + prefService.getPrefType(this.PREF_UPDATE_URL));
  104.                 }
  105.                 catch(e)
  106.                 {
  107.                     dump("Caught Exception trying to dump prefs : " + e);
  108.                     return;
  109.                 }
  110.             }
  111.       }
  112.         else
  113.         {
  114.             // Not good if we are here.  let's dump a msg and bail
  115.             this.debug("Pref service unavailable.  Aborting feature discovery update.");
  116.             return;
  117.         }
  118.     },
  119.     
  120.     /*
  121.     *****************************************************************
  122.     * Function:  FetchNewDatFile()
  123.     * Arguments: None
  124.     * Return: None
  125.     * Description: Retrieves the latest featurediscovery.dat file
  126.     *        from the remote datastore using the nsIXPInstallManager
  127.     *        service.
  128.     * Author: Ryan Fransen
  129.     *****************************************************************
  130.     */
  131.     FetchNewDatFile : function() {
  132.         this.debug("Starting 'FetchNewDatFile'");
  133.         // Lets find out where the remote .dat file is.
  134.         this.remoteupdatefile = new Array(1);
  135.         this.remoteupdatefile[0] = prefService.getCharPref(this.PREF_UPDATE_URL)
  136.         // Lets get the ball rolling with the update service
  137.         var xpimgr = Components.classes["@mozilla.org/xpinstall/install-manager;1"]
  138.                                 .createInstance(Components.interfaces.nsIXPInstallManager);
  139.                                 
  140.         if (xpimgr)
  141.         {
  142.             // Engage!
  143.             xpimgr.initManagerFromChrome(this.remoteupdatefile, this.remoteupdatefile.length, this);
  144.                         
  145.             // We should probably wait to load the .dat file until the update
  146.             // service has finished loading it.  So there must be some sort of callback for
  147.             // this... Aha!  There is.  It is called "OnStateChange" via the
  148.             // nsIXPIProgressDialog::INSTALL_DONE flag.
  149.             // Hm...  What if the download fails, or takes WAY too long, what then?
  150.             // We would have no feature discovery file loaded at that point...
  151.             // Well, we could just go ahead and load the local one at startup, and then
  152.             // re-load the file again once we get the new one.
  153.         }
  154.         else
  155.         {
  156.             // Note the failure and abort
  157.             this.debug("nsIXPInstallManager service unavailable.");
  158.             return;
  159.         }
  160.     },
  161.     
  162.     /*
  163.     *****************************************************************
  164.     * Function:  NowInSeconds()
  165.     * Arguments: None
  166.     * Return: The current workstation time in seconds (Unix Time/1000)
  167.     * Description: Provides a way to get a time reference.
  168.     * Author: Ryan Fransen
  169.     *****************************************************************
  170.     */
  171.     NowInSeconds : function ()
  172.     {
  173.         return new Date().valueOf() / 1000;
  174.     },
  175.     
  176.     /*
  177.     *****************************************************************
  178.     * Function:  onStateChange()
  179.     * Arguments: aIndex, aState, aValue
  180.     * Return: None
  181.     * Description: Callback from nsIXPInstallManager.
  182.     *        Handles the various states that the install manager goes through
  183.     *        that we may be interested in.  Of course, we really only care
  184.     *        about one state - INSTALL_DONE
  185.     * Author: Ryan Fransen
  186.     *****************************************************************
  187.     */
  188.     onStateChange : function (aIndex, aState, aValue)
  189.     {
  190.         this.debug("OnStateChange");
  191.       const nsIXPIProgressDialog = Components.interfaces.nsIXPIProgressDialog;
  192.       switch (aState)
  193.       {
  194.           case nsIXPIProgressDialog.DOWNLOAD_START:
  195.           case nsIXPIProgressDialog.DOWNLOAD_DONE:
  196.           case nsIXPIProgressDialog.INSTALL_START:
  197.             //  Do nothing
  198.             break;
  199.           case nsIXPIProgressDialog.INSTALL_DONE:
  200.               // Call our local oninstalldone handler
  201.                  this.OnInstallDone();
  202.                  break;
  203.         }
  204.     },
  205.     
  206.     /*
  207.     *****************************************************************
  208.     * Function:  OnInstallDone()
  209.     * Arguments: None
  210.     * Return: None
  211.     * Description: Performs any post .dat file install work
  212.     * Author: Ryan Fransen
  213.     *****************************************************************
  214.     */
  215.     OnInstallDone : function ()
  216.     {
  217.         // It is finally time to read in the feaurediscovery.dat file into memory and process it.
  218.         try
  219.         {
  220.             this.ReadFeatureDiscovery();
  221.         }
  222.         catch(e)
  223.         {
  224.             // Ok, so we couldn't load the new featurediscovery.dat file, what should we do?
  225.             // Note the failure and bail - don't update the lastupdatedate pref.
  226.             this.debug("ReadFeatureDiscovery() failed!");
  227.             return;
  228.         }
  229.         
  230.         // Now that we have fetched the new .dat file, we should probably
  231.         // capture the current time and save it in the lastupdatedate pref.
  232.         try
  233.         {
  234.             prefService.setIntPref(this.PREF_LASTUPDATEDATE, this.NowInSeconds());
  235.         }
  236.         // We don't want to bail if this fails.  We should note the failure.
  237.         catch(e)
  238.         {
  239.             dump("Caught Exception trying to set pref 'browser.featurediscovery.lastupdatedate': " + e);
  240.         }
  241.         
  242.         this.debug("Install complete");
  243.     },
  244.     
  245.     // We don't really need this callback,
  246.     // so let's just placate the install service
  247.     // and play nicely with the other kids
  248.     onProgress    : function(aIndex, aValue, aMaxValue) {},
  249.     
  250.   // END - rfransen
  251.   
  252.       
  253.     GetFeatureDiscoveryFile : function() {
  254.         this.debug('GetFeatureDiscoveryFile(): '+this.FEATURE_DISCOVERY_FILE);
  255.  
  256.         if (!this.datFileDir) this.Init();
  257.  
  258.         // Create file descriptor
  259.         if (this.datFileDir) {
  260.          var file = this.datFileDir.clone();
  261.          file.append(this.FEATURE_DISCOVERY_FILE);
  262.          return file; // returns nsILocalFile
  263.         }
  264.        else
  265.         return null;
  266.     },
  267.  
  268.     EnsureFeatureDiscoveryFileExists : function() {
  269.         this.debug('EnsureFeatureDiscoveryFileExists()');
  270.         var file = this.GetFeatureDiscoveryFile();
  271.         //this.debug('EnsureFeatureDiscoveryFileExists() - file is ' + file);
  272.         if (!file.exists()) {
  273.             this.debug(' creating file: '+this.FEATURE_DISCOVERY_FILE);
  274.             file.create(Components.interfaces.nsIFile.NORMAL_FILE_TYPE, 0);
  275.         }
  276.         return file; // returns nsILocalFile
  277.     },
  278.  
  279.     ReadFeatureDiscovery : function() {
  280.         this.debug('ReadFeatureDiscovery()');
  281.  
  282.         var file = this.EnsureFeatureDiscoveryFileExists();
  283.  
  284.       if (file) {
  285.           // Init the file input stream
  286.           var fis = Components.classes["@mozilla.org/network/file-input-stream;1"]
  287.                             .createInstance(Components.interfaces.nsIFileInputStream);
  288.           fis.init(file, this.PR_RDONLY, 0, 0);
  289.  
  290.           // Init a scriptable input stream
  291.           var sis = Components.classes["@mozilla.org/scriptableinputstream;1"]
  292.                             .createInstance(Components.interfaces.nsIScriptableInputStream);
  293.           sis.init(fis);
  294.  
  295.           // Read the file
  296.           var fileContents = sis.read(sis.available());
  297.  
  298.           // Close file
  299.           fis.close();
  300.  
  301.           // Return the lines as an array
  302.           this.featureList = fileContents.split('\n');
  303.  
  304.           //return fileContents.split('\n');
  305.        }
  306.        //return null;
  307.     },
  308.  
  309.     ProcessFeatureDiscovery : function(uri) {
  310.         // Determine if this uri is found in the list of feature discovery urls.
  311.  
  312.         uriservice.spec = uri;
  313.         var host = uriservice.host;
  314.  
  315.         this.debug('ProcessFeatureDiscovery()');
  316.         
  317.         var featureType = null;  // return string value (e.g. searchbar)
  318.         
  319.         if (uriservice.scheme == "http" || uriservice == "https")
  320.         {
  321.             if (!this.featureList)
  322.                 this.ReadFeatureDiscovery();
  323.     
  324.             // Load in the feature discovery urls
  325.             var entries = this.featureList; //this.ReadFeatureDiscovery();
  326.     
  327.     
  328.             if (entries) {
  329.                 host=host.toLowerCase();   // match "ABC.com" and "abc.com"
  330.     
  331.                 var blnFoundMatch = false;  // did we find a match?
  332.                 var i;                      // loop index
  333.     
  334.                 // loop for each feature discovery URL in the file until a match is found or
  335.                 //   we have looped too many times
  336.                 this.debug('Searching through : ' + entries.length);
  337.                 for (i = 0; i < entries.length && !blnFoundMatch && i < this.MAX_NUMBER_FEATURES; i++) {
  338.                     // each line in featurediscovery.dat is x|y  where x is the URL and y is the
  339.                     //  feature discovery type (e.g. searchbar) - whitespace is trimmed out in code
  340.                     // parse out the line into the featureURL array
  341.                   featureURL = entries[i].split('|');
  342.                   if (featureURL) {
  343.                         // if featureURL[0] is found in host, the indexOf returns something other than -1
  344.                         //   trim removes any trailing whitespace
  345.                         this.debug('Searching for [' + trim(featureURL[0].toLowerCase()) + '] in [' + host + ']');
  346.                         if (host.indexOf(trim(featureURL[0].toLowerCase())) != -1) {
  347.                           // trip the flag to end the loop
  348.                           this.debug('Found match [' + trim(featureURL[0].toLowerCase()) + '] in [' + host + ']');
  349.                           blnFoundMatch = true;
  350.                           featureType = featureURL;
  351.                         } // end if
  352.                     }
  353.                 } // end for
  354.                 if (i >= this.MAX_NUMBER_FEATURES)
  355.                     this.debug('Reached max number of features in featurediscovery.dat.');
  356.     
  357.             } else { // else no file was found so return null
  358.                 this.debug('Unable to read entries from array.');
  359.             }
  360.         }
  361.         return featureType;
  362.     },
  363.  
  364.     debug : function(msg) {
  365.             if (this.FD_DEBUG)
  366.                 dump('^^^ featureDiscovery.js: '+msg+'\n');
  367.     },
  368.  
  369.     trim : function(str) {
  370.         if (!str) return "";
  371.         str = str.replace(/^\s+/, "");
  372.         return str.replace(/\s+$/, "");
  373.     }
  374.  
  375. };