sbLibrarySearchSuggester.js

Go to the documentation of this file.

Components.utils.import("resource://gre/modules/XPCOMUtils.jsm");
Components.utils.import("resource://app/jsmodules/sbProperties.jsm");

const Cc = Components.classes;
const Ci = Components.interfaces;
const Cr = Components.results;

const CONTRACTID = "@mozilla.org/autocomplete/search;1?name=library-distinct-properties";
const DESCRIPTION = "Songbird Library Search Suggestions";
const CID = Components.ID("{1ed101bc-a11c-4e03-83af-514672bd3a70}");

const XPCOM_SHUTDOWN_TOPIC              = "xpcom-shutdown";


var gDefaultValues = {};
gDefaultValues["audio"] = [
  "Alternative", "Blues/R&B", "Books&Spoken", "Children's Music",
  "Classical", "Comedy", "Country", "Dance", "Easy Listening", "World",
  "Electronic", "Folk", "Hip Hop/Rap", "Holiday", "House", "Industrial",
  "Jazz", "New Age", "Nerdcore", "Podcast", "Pop", "Reggae", "Religious",
  "Rock", "Science", "Soundtrack", "Techno", "Trance", "Unclassifiable",
];

gDefaultValues["video"] = [
  "Children's", "Comedy", "Drama", "Entertainment", "Healthcare & Fitness",
  "Travel", "Unclassifiable",
];

function AutoCompleteResult(searchString,
                                   defaultIndex,
                                   errorDescription,
                                   results) {
  this._searchString = searchString;
  this._defaultIndex = defaultIndex;
  this._errorDescription = errorDescription;
  this._results = results;
}
AutoCompleteResult.prototype = {
  _searchString: "",

  _defaultIndex: 0,

  _errorDescription: "",

  _results: [],

  get searchString() {
    return this._searchString;
  },

  get searchResult() {
    if (this._results.length > 0) {
      return Ci.nsIAutoCompleteResult.RESULT_SUCCESS;
    } else {
      return Ci.nsIAutoCompleteResult.RESULT_NOMATCH;
    }
  },

  get defaultIndex() {
    return this._defaultIndex;
  },

  get errorDescription() {
    return this._errorDescription;
  },

  get matchCount() {
    return this._results.length;
  },

  getValueAt: function(index) {
    return this._results[index];
  },

  getCommentAt: function(index) {
    return "";
  },

  getStyleAt: function(index) {
    if (!this._results[index])
      return null;  // not a category label, so no special styling

    if (index == 0)
      return "suggestfirst";  // category label on first line of results

    return "suggesthint";   // category label on any other line of results
  },

  getImageAt: function(index) { 
    return ""; 
  },
     
  removeValueAt: function(index, removeFromDatabase) {
    this._results.splice(index, 1);
  },

  QueryInterface: function(iid) {
    if (!iid.equals(Ci.nsIAutoCompleteResult) &&
        !iid.equals(Ci.nsISupports))
      throw Cr.NS_ERROR_NO_INTERFACE;
    return this;
  }
};






function LibrarySearchSuggester() {
    var os = Cc["@mozilla.org/observer-service;1"]
               .getService(Ci.nsIObserverService);
    os.addObserver(this, XPCOM_SHUTDOWN_TOPIC, false);
}

LibrarySearchSuggester.prototype = {
  classDescription: DESCRIPTION,
  classID:          Components.ID(CID),
  contractID:       CONTRACTID,

  _listener: null,
  _libraryManager: null,
  _lastSearch: null,
  _timer: null,
  _distinctValues: null,
  _cacheParam: null,


  onSearchResult: function(searchString, results) {
    if (this._listener) {
      var result = new AutoCompleteResult(
          searchString,
          0,
          "",
          results);

      this._listener.onSearchResult(this, result);

      // Null out listener to make sure we don't notify it twice, in case our
      // timer callback still hasn't run.
      this._listener = null;
    }
  },


  startSearch: function(searchString, searchParam, previousResult, listener) {

    // If no property was specified, we can't perform a search, abort now
    if (!searchParam ||
        searchParam == "") {
      // notify empty result, probably not needed but hey, why not.
      this.onSearchResult(searchString, []);
      return;
    }
      
    // If there's an existing request, stop it
    this.stopSearch();

    // remember the listener
    this._listener = listener;
    
    // if we do not yet have the distinct values, or if they
    // have been invalidated, get them again now.
    if (!this._distinctValues ||
        this._cacheParam != searchParam) {
      
      // remember current search param
      this._cacheParam = searchParam;
      
      // discard previous results no matter what,
      // we want to use the new data
      previousResult = null;
      
      // start anew
      this._distinctValues = {};

      // get the library manager if needed
      if (!this._libraryManager) {
        this._libraryManager = 
          Cc["@songbirdnest.com/Songbird/library/Manager;1"]
            .getService(Ci.sbILibraryManager);
      }

      // parse search parameters
      var params = searchParam.split(";");

      var properties = params[0].split("$");
      this._prop = properties[0];
      this._type = properties[1] || "audio";

      var guid = params[1];
      var additionalValues = params[2];
      this._conversionUnit = params[3];

      if (this._type != "video") {
        // Record distinct values for a library
        function getDistinctValues(aLibrary, prop, obj) {
          if (!aLibrary) 
            return;
          var values = aLibrary.getDistinctValuesForProperty(prop);
          while (values.hasMore()) { 
            // is there a way to assert a key without doing an assignment ?
            obj._distinctValues[values.getNext()] = true;
          }
        }

        // If we have a guid in the params, get the distinct values
        // from a library with that guid, otherwise, get them from
        // all libraries
        if (guid && guid.length > 0) {
          getDistinctValues(this._libraryManager.getLibrary(guid),
                            this._prop, this);
        } else {
          var libs = this._libraryManager.getLibraries();
          while (libs.hasMoreElements()) {
            getDistinctValues(libs.getNext(), this._prop, this);
          }
        }
      }

      // If we have additional values, add them to the 
      // distinct values array
      if (additionalValues && additionalValues.length > 0) {
        var values = additionalValues.split(",");
        for each (var value in values) {
          this._distinctValues[value] = true;
        }
      }
      
      // Add hardcoded values, if any
      this._addDefaultDistinctValues();
      
      // set this cache to expire in 5s

      if (!this._timer)
        this._timer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer);

      this._timer.cancel();
      this._timer.initWithCallback(this, 5000, this._timer.TYPE_ONE_SHOT);
    }

    // our search is case insensitive
    var search = searchString.toLowerCase();

    // matching function
    function startsWith(aString, aPartial) {
      return (!aPartial ||
               aPartial == "" ||
               aString.toLowerCase().slice(0, aPartial.length) == aPartial);
    }

    var results = [];
    
    // if this is a narrowing down of the previous search,
    // use the previousResults array, otherwise,
    // use the full distinctValues array
    
    if (previousResult &&
        startsWith(search, this._lastSearch)) {
      for (var i = 0 ; i < previousResult.matchCount ; i++) {
        var value = previousResult.getValueAt(i);
        if (startsWith(value, search))
          results.push(value);
      }
    } else {

      var converter = null;
      if (this._conversionUnit && this._conversionUnit != "") {
        var propertyManager = 
          Cc["@songbirdnest.com/Songbird/Properties/PropertyManager;1"]
            .getService(Ci.sbIPropertyManager);
        var info = propertyManager.getPropertyInfo(this._prop);
        converter = info.unitConverter;
      }

      for (var value in this._distinctValues) {
        if (converter) {
          value = converter.convert(value, 
                                    converter.nativeUnitId, 
                                    this._conversionUnit, 
                                    -1, -1 /* no min/max decimals */);
        }
        if (startsWith(value, search))
          results.push(value);
      }
    }
    
    // remember the last search string, to see if 
    // we can use previousResult next time.
    this._lastSearch = search;
    
    // Notify the listener that we got results
    this.onSearchResult(searchString, results);    
  },
  
  // one shot timer notification method
  notify: function(timer) {
    this._lastSearch = null;
    this._distinctValues = null;
  },

  stopSearch: function() {
    // Nothing to do since we return our searches immediately.
  },

  _addDefaultDistinctValues: function() {
    var defaults = gDefaultValues[this._type];
    if (defaults) {
      for each (var value in defaults) {
        this._distinctValues[value] = true;
      }
    }
  },

  observe: function SAC_observe(aSubject, aTopic, aData) {
    switch (aTopic) {
      case XPCOM_SHUTDOWN_TOPIC:
        this.stopSearch();
        this._libraryManager = null;
        if (this._timer) {
          this._timer.cancel();
          this._timer = null;
        }
        var os = Cc["@mozilla.org/observer-service;1"]
                   .getService(Ci.nsIObserverService);
        os.removeObserver(this, XPCOM_SHUTDOWN_TOPIC);
        break;
    }
  },

  QueryInterface:
    XPCOMUtils.generateQI([Ci.nsIAutoCompleteSearch,
                           Ci.nsIObserver])
};

function NSGetModule(compMgr, fileSpec) {
  return XPCOMUtils.generateModule([LibrarySearchSuggester]);
}