sbSearchSuggester.js

Go to the documentation of this file.

const BROWSER_SUGGEST_PREF = "browser.search.suggest.enabled";
const XPCOM_SHUTDOWN_TOPIC              = "xpcom-shutdown";
const NS_PREFBRANCH_PREFCHANGE_TOPIC_ID = "nsPref:changed";

const SONGBIRD_DATAREMOTE_CONTRACTID = "@songbirdnest.com/Songbird/DataRemote;1";
const sbIDataRemote            = Components.interfaces.sbIDataRemote;


const SEARCH_SUGGEST_CONTRACTID =
  "@mozilla.org/autocomplete/search;1?name=songbird-autocomplete";
const SEARCH_SUGGEST_CLASSNAME = "Songbird Search Suggestions";
const SEARCH_SUGGEST_CLASSID =
  Components.ID("{0be64502-ee00-11db-8314-0800200c9a66}");

const SEARCH_BUNDLE = "chrome://songbird/locale/songbird.properties";

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


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

  _defaultIndex: 0,

  _errorDescription: "",

  _results: [],

  _comments: [],


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

  get searchResult() {
    if (this._results.length > 0) {
      return Ci.nsIAutoCompleteResult.RESULT_SUCCESS;
    } else {
      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 this._comments[index];
  },

  getStyleAt: function(index) {
    if (!this._comments[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);
    this._comments.splice(index, 1);
  },

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






function SearchSuggester() {
  this._addObservers();
  this._loadSuggestPref();
  this._loadDataRemotes();
}
SearchSuggester.prototype = {

  get _strings() {
    if (!this.__strings) {
      var sbs = Cc["@mozilla.org/intl/stringbundle;1"].
                getService(Ci.nsIStringBundleService);

      this.__strings = sbs.createBundle(SEARCH_BUNDLE);
    }
    return this.__strings;
  },
  __strings: null,

  _loadSuggestPref: function SAC_loadSuggestPref() {
    var prefService = Cc["@mozilla.org/preferences-service;1"].
                      getService(Ci.nsIPrefBranch);
    this._suggestEnabled = prefService.getBoolPref(BROWSER_SUGGEST_PREF);
  },
  _suggestEnabled: null,

  // Metadata for the current playing track in Songbird
  _metadataTitle:  null,
  _metadataArtist: null,
  _metadataAlbum:  null,
  
  _loadDataRemotes: function SAC_loadDataRemotes() {
  
    // TODO: Is this an issue?  Should I be waiting for profile load before doing this?
    var createDataRemote = new Components.Constructor( 
                SONGBIRD_DATAREMOTE_CONTRACTID, sbIDataRemote, "init");
    this._metadataTitle   = createDataRemote("metadata.title", null);
    this._metadataArtist  = createDataRemote("metadata.artist", null);
    this._metadataAlbum   = createDataRemote("metadata.album", null);
  },  
  
  _releaseDataRemotes: function() {
    this._metadataTitle.unbind();
    this._metadataArtist.unbind();
    this._metadataAlbum.unbind();
  },  


  _listener: null,


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

      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) {
    this.stopSearch();
    
    var searchService = Cc["@mozilla.org/browser/search-service;1"].
                        getService(Ci.nsIBrowserSearchService);

    // If there's an existing request, stop it
    this.stopSearch();

    this._listener = listener;

    var results = [];

    var engine = searchService.currentEngine;

    // Normally we would do something asynchronous, but since 
    // for now all we're returning is dataremote values, we
    // might as well just do it immediately.
    
    // If there is no search query then get some default suggestions
    if (searchString == "") {
      results = this._getPlayerContextSuggestions();    
    }
    
    // TODO Add a localized comment
    var comments = [];
    for (var i = 0; i < results.length; i++) {
      comments.push("");
    }

    this.onSearchResult(searchString, results, comments);    
  },

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


  _getPlayerContextSuggestions: function() {
    var results = [];
    
    // TODO: Do not return metadata unless playing or paused!
    // Currently returns metadata from the previous session.
    
    if (this._metadataTitle.stringValue != "") {
      results.push(this._metadataTitle.stringValue);
    }
    if (this._metadataAlbum.stringValue != "") {
      results.push(this._metadataAlbum.stringValue);
    }
    if (this._metadataArtist.stringValue != "") {
      results.push(this._metadataArtist.stringValue);
    }
    return results;
  },


  observe: function SAC_observe(aSubject, aTopic, aData) {
    switch (aTopic) {
      case NS_PREFBRANCH_PREFCHANGE_TOPIC_ID:
        this._loadSuggestPref();
        break;
      case XPCOM_SHUTDOWN_TOPIC:
        this.stopSearch();
        this._removeObservers();
        this._releaseDataRemotes();
        break;
    }
  },

  _addObservers: function SAC_addObservers() {
    var prefService2 = Cc["@mozilla.org/preferences-service;1"].
                       getService(Ci.nsIPrefBranch2);
    prefService2.addObserver(BROWSER_SUGGEST_PREF, this, false);

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

  _removeObservers: function SAC_removeObservers() {
    var prefService2 = Cc["@mozilla.org/preferences-service;1"].
                       getService(Ci.nsIPrefBranch2);
    prefService2.removeObserver(BROWSER_SUGGEST_PREF, this);

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

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



var gModule = {
  registerSelf: function(componentManager, location, loaderString, type) {
    if (this._firstTime) {
      this._firstTime = false;
      throw Cr.NS_ERROR_FACTORY_REGISTER_AGAIN;
    }
    componentManager =
      componentManager.QueryInterface(Ci.nsIComponentRegistrar);

    for (var key in this.objects) {
      var obj = this.objects[key];
      componentManager.registerFactoryLocation(obj.CID, obj.className, obj.contractID,
                                               location, loaderString, type);
    }
  },

  getClassObject: function(componentManager, cid, iid) {
    if (!iid.equals(Ci.nsIFactory))
      throw Cr.NS_ERROR_NOT_IMPLEMENTED;

    for (var key in this.objects) {
      if (cid.equals(this.objects[key].CID))
        return this.objects[key].factory;
    }

    throw Cr.NS_ERROR_NO_INTERFACE;
  },

  _makeFactory: function(constructor) {
    function createInstance(outer, iid) {
      if (outer != null)
        throw Cr.NS_ERROR_NO_AGGREGATION;
      return (new constructor()).QueryInterface(iid);
    }
    return { createInstance: createInstance };
  },

  canUnload: function(componentManager) {
    return true;
  }
};

function NSGetModule(componentManager, location) {
  // Metadata about the objects this module can construct
  gModule.objects = {
    search: {
      CID: SEARCH_SUGGEST_CLASSID,
      contractID: SEARCH_SUGGEST_CONTRACTID,
      className: SEARCH_SUGGEST_CLASSNAME,
      factory: gModule._makeFactory(SearchSuggester)
    },
  };
  return gModule;
}