deviceInfo.js

Go to the documentation of this file.

/* -*- Mode: Java; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set sw=2 :miv */
/*
 *=BEGIN SONGBIRD GPL
 *
 * This file is part of the Songbird web player.
 *
 * Copyright(c) 2005-2010 POTI, Inc.
 * http://www.songbirdnest.com
 *
 * This file may be licensed under the terms of of the
 * GNU General Public License Version 2 (the ``GPL'').
 *
 * Software distributed under the License is distributed
 * on an ``AS IS'' basis, WITHOUT WARRANTY OF ANY KIND, either
 * express or implied. See the GPL for the specific language
 * governing rights and limitations.
 *
 * You should have received a copy of the GPL along with this
 * program. If not, go to http://www.gnu.org/licenses/gpl.html
 * or write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 *=END SONGBIRD GPL
 */

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//
// Device info widget.
//
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
//
// Device info imported services.
//
//------------------------------------------------------------------------------

// Component manager defs.
if (typeof(Cc) == "undefined")
  var Cc = Components.classes;
if (typeof(Ci) == "undefined")
  var Ci = Components.interfaces;
if (typeof(Cr) == "undefined")
  var Cr = Components.results;
if (typeof(Cu) == "undefined")
  var Cu = Components.utils;

// Songbird imports.
Cu.import("resource://app/jsmodules/DOMUtils.jsm");
Cu.import("resource://app/jsmodules/SBTimer.jsm");


//------------------------------------------------------------------------------
//
// Device info defs.
//
//------------------------------------------------------------------------------

// DOM defs.
if (typeof(XUL_NS) == "undefined")
  var XUL_NS = "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul";


//------------------------------------------------------------------------------
//
// Device info services.
//
//------------------------------------------------------------------------------

var DIW = {
  //
  // Device info configuration.
  //
  //   _pollPeriodTable         Table of polling periods for device information
  //                            that needs to be polled.
  //   _contextMenuDocURL       URL to context menu document.
  //

  _pollPeriodTable: { "battery": 60000, "firmware_version": 60000 },
  _contextMenuDocURL:
    "chrome://songbird/content/xul/device/deviceContextMenu.xul",


  //
  // Device info object fields.
  //
  //   _widget                  Device info widget.
  //   _device                  Device bound to widget.
  //   _deviceProperties        Device properties.
  //   _deviceLibrary           Bound device library.
  //   _contextMenuEnabled      If true, the context menu is enabled.
  //   _contextMenuPopup        Context menu popup.
  //

  _widget: null,
  _device: null,
  _deviceProperties: null,
  _deviceLibrary: null,
  _contextMenuEnabled: false,
  _contextMenuPopup: null,


  initialize: function DIW__initialize(aWidget) {
    // Get the device info widget.
    this._widget = aWidget;

    // Initialize object fields.
    this._device = this._widget.device;
    this._deviceProperties = this._device.properties;
    this._deviceLibrary = this._widget.devLib;

    // Initialize the context menu.
    this._initializeContextMenu();

    // Show specified elements.
    this._showElements();

    // Hide labels if needed
    this._hideLabels();

    // Initialize the device spec rows.
    this._deviceSpecInitialize();

    // Update the UI.
    this._update();

    // Watch for device changes
    this._device.QueryInterface(Ci.sbIDeviceEventTarget).addEventListener(this);
  },

  onDeviceEvent : function DIW_onDeviceEvent(anEvent) {
    if (anEvent.type == Ci.sbIDeviceEvent.EVENT_DEVICE_INFO_CHANGED) {
      this._update();
    }
  },
  finalize: function DIW_finalize() {
    // Finalize the polling services.
    this._pollingFinalize();

    // Stop listening
    if (this._device != null) {
      this._device.QueryInterface(Ci.sbIDeviceEventTarget)
                  .removeEventListener(this);
    }

    // Finalize the device services.
    this._deviceFinalize();

    // Clear object fields.
    this._widget = null;
    this._deviceLibrary = null;
    this._contextMenuPopup = null;
  },


  //----------------------------------------------------------------------------
  //
  // Device info device spec row services.
  //
  // NOTE: These services may move the device spec rows within the document.
  //       Doing so disables the use of certain XUL element properties such as
  //       value.  Thus, attributes must be used instead of properties.
  //
  //----------------------------------------------------------------------------

  _deviceSpecInitialize: function DIW__deviceSpecInitialize() {
    // Get the list of device specs to present.
    var deviceSpecs = this._widget.getAttribute("devicespecs");
    var deviceSpecList = deviceSpecs.split(",");

    // Get the list of device spec row elements.
    var deviceSpecRows = this._getElement("device_spec_rows");
    var deviceSpecRowList = deviceSpecRows.getElementsByTagNameNS(XUL_NS,
                                                                  "row");

    // Hide all device spec rows.
    for (var i = 0; i < deviceSpecRowList.length; i++) {
      deviceSpecRowList[i].hidden = true;
    }

    // Move and update specified device spec rows into position.  Also determine
    // the device info polling period.
    var pollPeriod = Number.POSITIVE_INFINITY;
    var refDeviceSpecRow = deviceSpecRows.firstChild;
    for (var i = 0; i < deviceSpecList.length; i++) {
      // Get the device spec and row.
      var deviceSpec = deviceSpecList[i];
      var deviceSpecRow = this._getDeviceSpecRow(deviceSpec);

      // Skip device spec if it's not supported.
      if (!this._supportsDeviceSpec(deviceSpec))
        continue;

      // Move the device spec row into position.
      if (deviceSpecRow != refDeviceSpecRow) {
        deviceSpecRows.insertBefore(deviceSpecRow, refDeviceSpecRow);
      }
      refDeviceSpecRow = deviceSpecRow.nextSibling;

      // Show the device spec row.
      deviceSpecRow.hidden = false;

      // Check the device spec polling period.
      var specPollPeriod = this._pollPeriodTable[deviceSpec];
      if (specPollPeriod && (specPollPeriod < pollPeriod))
        pollPeriod = specPollPeriod;
    }

    // Start polling if needed.
    if (pollPeriod != Number.POSITIVE_INFINITY)
      this._pollingInitialize(pollPeriod);
  },


  _deviceSpecUpdateAll: function DIW__deviceSpecUpdateAll() {
    // Update all of the shown device spec rows.
    var deviceSpecRows = this._getElement("device_spec_rows");
    var deviceSpecRowList = deviceSpecRows.getElementsByTagNameNS
              ("http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul",
               "row");
    for (var i = 0; i < deviceSpecRowList.length; i++) {
      var deviceSpecRow = deviceSpecRowList[i];
      if (!deviceSpecRow.hidden)
        this._deviceSpecUpdate(deviceSpecRow);
    }
  },


  _deviceSpecUpdate: function DIW__deviceSpecUpdate(aRow) {
    // Dispatch updating.
    var deviceSpec = aRow.getAttribute("devicespec");
    switch (deviceSpec) {
      case "model" :
        this._deviceSpecUpdateValue(aRow,
                                    "model_value_label",
                                    this._getDeviceModel());
        break;

      case "capacity" :
        this._deviceSpecUpdateValue(aRow,
                                    "capacity_value_label",
                                    this._getDeviceModelSize());
        break;

      case "model_capacity" :
        this._deviceSpecUpdateModelCapacity(aRow);
        break;

      case "product_capacity" :
        this._deviceSpecUpdateProductCapacity(aRow);
        break;

      case "friendly_name" :
        this._deviceSpecUpdateValue(aRow,
                                    "friendly_name_value_label",
                                    this._getDeviceFriendlyName());
        break;

      case "serial_number" :
        this._deviceSpecUpdateValue(aRow,
                                    "serial_number_value_label",
                                    this._getDeviceSerialNumber());
        break;

      case "vendor" :
        this._deviceSpecUpdateValue(aRow,
                                    "vendor_value_label",
                                    this._getDeviceVendor());
        break;

      case "access" :
        this._deviceSpecUpdateValue(aRow,
                                    "access_value_label",
                                    this._getDeviceAccessCompatibilityDesc());
        break;

      case "playback_formats" :
        this._deviceSpecUpdateDesc(aRow,
                                   "playback_formats_value_label",
                                   this._getDevicePlaybackFormats());
        break;

      case "battery" :
        this._deviceSpecUpdateBattery(aRow);
        break;

      case "firmware_version":
        this._deviceSpecUpdateValue(aRow,
                                    "firmware_version_value_label",
                                    this._getDeviceFirmwareVersion());
        break;

      default :
        break;
    }
  },


  _deviceSpecUpdateValue: function DIW__deviceSpecUpdateValue(aRow,
                                                              aLabelID,
                                                              aValue) {
    // Set the row no value attribute.
    if (aValue && aRow.hasAttribute("novalue"))
      aRow.removeAttribute("novalue");
    else if (!aValue && (aRow.getAttribute("novalue") != "true"))
      aRow.setAttribute("novalue", true);

    // Set the value label.
    var labelElem = this._getElement(aLabelID);
    if (labelElem.getAttribute("value") != aValue)
      labelElem.setAttribute("value", aValue);
  },


  _deviceSpecUpdateDesc: function DIW__deviceSpecUpdateDesc(aRow,
                                                            aDescID,
                                                            aText) {
    // Set the row no value attribute.
    if (aText && aRow.hasAttribute("novalue"))
      aRow.removeAttribute("novalue");
    else if (!aText && (aRow.getAttribute("novalue") != "true"))
      aRow.setAttribute("novalue", true);

    // Set the description text.
    var descElem = this._getElement(aDescID);
    if (descElem.firstChild.data != aText)
      descElem.firstChild.data = aText;
  },


  _deviceSpecUpdateModelCapacity: function
                                    DIW__deviceSpecUpdateModelCapacity(aRow) {
    // Get the device model and model capacity.
    var devModelValue = this._getDeviceModel();
    var devCapValue = this._getDeviceModelSize();
    var devModelCapValue = devModelValue + " (" + devCapValue + ")";

    // Upate the device model/capacity.
    this._deviceSpecUpdateValue(aRow,
                                "model_capacity_value_label",
                                devModelCapValue);
  },


  _deviceSpecUpdateProductCapacity: function
                                    DIW__deviceSpecUpdateProductCapacity(aRow) {
    // Get the device product name
    var devProductValue = this._getDeviceProduct();

    // Get the device capacity.
    var capacity = "";
    if (this._deviceLibrary) {
      try {
        storageConverter =
          Cc["@songbirdnest.com/Songbird/Properties/UnitConverter/Storage;1"]
            .createInstance(Ci.sbIPropertyUnitConverter);
        capacity = this._deviceLibrary.getProperty
                     ("http://songbirdnest.com/device/1.0#capacity");
        capacity = storageConverter.autoFormat(capacity, -1, 1);
      } catch (ex) {};
    }

    var devProductCapValue = SBFormattedString("device.info.product_cap",
                             [ devProductValue, capacity ]);
 
    // Upate the device model/capacity.
    this._deviceSpecUpdateValue(aRow,
                                "product_capacity_value_label",
                                devProductCapValue);
  },


  _deviceSpecUpdateBattery: function DIW__deviceSpecUpdateBattery(aRow) {
    // Get the battery status.
    var batteryLevel = {};
    var onBatteryPower = {};
    this._getDeviceBatteryStatus(batteryLevel, onBatteryPower);
    batteryLevel = batteryLevel.value;
    onBatteryPower = onBatteryPower.value;
    var batteryStatus;
    if (onBatteryPower)
      batteryStatus = "battery-powered";
    else if (batteryLevel == 100)
      batteryStatus = "charged";
    else
      batteryStatus = "charging";

    // Update the battery status and level.
    var batteryElem = this._getElement("battery_status");
    if (batteryLevel == -1) {
      batteryElem.hidden = true;
    }
    else {
      batteryElem.hidden = false;
      if ((batteryElem.getAttribute("status") != batteryStatus) ||
        (batteryElem.getAttribute("level") != batteryLevel)) {
        batteryElem.setAttribute("status", batteryStatus);
        batteryElem.setAttribute("level", batteryLevel);
      }
    }
  },


  //----------------------------------------------------------------------------
  //
  // Device info context menu services.
  //
  //----------------------------------------------------------------------------

  _initializeContextMenu: function DIW__initializeContextMenu() {
    // Check if the context menu is enabled.  Do nothing more if not.
    if (this._widget.getAttribute("enable_context_menu") == "true") {
      this._contextMenuEnabled = true;
    } else {
      this._contextMenuEnabled = false;
      return;
    }

    // Get the content menu popup and clear it.
    this._contextMenuPopup = this._getElement("context_menu_popup");
    while (this._contextMenuPopup.hasChildNodes()) {
      this._contextMenuPopup.removeChild(this._contextMenuPopup.firstChild);
    }

    // Import the device context menu items.
    var deviceContextMenuDoc = DOMUtils.loadDocument(this._contextMenuDocURL);
    DOMUtils.importChildElements(this._contextMenuPopup,
                                 deviceContextMenuDoc,
                                 "device_context_menu_items",
                                 { "device-id": this._device.id });
  },


  onContextMenu: function DIW_onContextMenu(aEvent) {
    // Do nothing if context menu is not enabled.
    if (!this._contextMenuEnabled)
      return;

    // Open the context menu popup.
    this._contextMenuPopup.openPopup(null,
                                     null,
                                     aEvent.clientX,
                                     aEvent.clientY,
                                     true,
                                     false);
  },


  //----------------------------------------------------------------------------
  //
  // Device info XUL services.
  //
  //----------------------------------------------------------------------------

  _getElement: function DIW__getElement(aElementID) {
    return document.getAnonymousElementByAttribute(this._widget,
                                                   "sbid",
                                                   aElementID);
  },


  _getDeviceSpecRow: function DIW__getDeviceSpecRow(aDeviceSpec) {
    return document.getAnonymousElementByAttribute(this._widget,
                                                   "devicespec",
                                                   aDeviceSpec);
  },


  _getShowElement: function DIW__getShowElement(aShowID) {
    return document.getAnonymousElementByAttribute(this._widget,
                                                   "showid",
                                                   aShowID);
  },


  //----------------------------------------------------------------------------
  //
  // Device info polling services.
  //
  //----------------------------------------------------------------------------

  //
  // Device info polling services fields.
  //
  //   _pollingTimer            Timer used for polling device info.
  //

  _pollingTimer: null,


  _pollingInitialize: function DIW__pollingInitialize(aPollPeriod) {
    // Start a timing interval to poll for device info UI updates.
    var _this = this;
    var func = function() { _this._update(); }
    this._pollingTimer = new SBTimer(func,
                                     aPollPeriod,
                                     Ci.nsITimer.TYPE_REPEATING_SLACK);
  },


  _pollingFinalize: function DIW__pollingFinalize() {
    if (this._pollingTimer) {
      this._pollingTimer.cancel();
      this._pollingTimer = null;
    }
  },


  //----------------------------------------------------------------------------
  //
  // Internal device info services.
  //
  //----------------------------------------------------------------------------

  _hideLabels: function DIW__hideLabels() {
    if (this._widget.getAttribute("hidelabels")) {
      this._getElement("device_specs_label_column").hidden = true;

      // Hide the labels
      var gridRows = this._getElement("device_spec_rows");

      // Each child of the <rows> is a <row> where the firstChild is
      // the label for product/model/etc.
      var rowElements = gridRows.getElementsByTagNameNS(XUL_NS, "row");
      for each (var row in rowElements) {
        if (row.firstChild)
          row.firstChild.hidden = true;
      }
    }
  },

  _showElements: function DIW__showElements() {
    // Get the list of elements to show.
    var showListAttr = this._widget.getAttribute("showlist");
    if (!showListAttr)
      return;
    var showList = this._widget.getAttribute("showlist").split(",");

    // Show the specified elements.
    for (var i = 0; i < showList.length; i++) {
      var element = this._getShowElement(showList[i]);
      element.hidden = false;
      if (element.parentNode.hidden)
        element.parentNode.hidden = false;
    }
  },


  _update: function DIW__update() {
    // Update the device name label.
    var devNameLabel = this._getElement("device_name_label");
    var devName = this._getDeviceName();
    if (devNameLabel.value != devName)
      devNameLabel.value = devName;

    // Update the device image.
    var devImage = this._getElement("device_image");
    var devIconURL = this._getDeviceIcon();
    if (devIconURL && (devImage.src != devIconURL))
      devImage.src = devIconURL;

    // If the device is read-only, then unhide the read-only lock icon
    // but only do it if the device image is also visible
    if (!devImage.hidden) {
      var lockImage = this._getElement("device_image_ro");
      var accessCompatibility = this._getDeviceAccessCompatibility();
      if (accessCompatibility == "ro")
        lockImage.hidden = false;
    }

    // Update the device specs.
    this._deviceSpecUpdateAll();
  },


  //----------------------------------------------------------------------------
  //
  // Device info device services.
  //
  //   These services provide an interface to the device object.
  //   These services register for any pertinent device notifications and call
  // _update to update the UI accordingly.  These include notifications for
  // changes to the device friendly name.
  //
  //----------------------------------------------------------------------------

  //
  // Device info services fields.
  //
  //   _lastPropertyValue       Holds the last value retrieved in case we
  //                            can't retrieve the property due to formatting
  //                            or other reasons
  
  _lastPropertyValue : {},
  
  _deviceFinalize: function DIW__deviceFinalize() {
    // Clear object fields.
    this._device = null;
  },

  _getDeviceProperty: function DIW__getDeviceProperty(aPropertyName, aDefault) {
    try {
      if (this._deviceProperties.properties.hasKey(aPropertyName)) {
        let value = this._deviceProperties.properties.getPropertyAsAString(
                                                                 aPropertyName);
        this._lastPropertyValue[aPropertyName] = value;
        return value;
      }    
    } catch (err) {
      if (this._lastPropertyValue[aPropertyName]) {
        return this._lastPropertyValue[aPropertyName];
      }
    }
    return aDefault;
  },

  _getDeviceModel: function DIW__getDeviceModel() {
    var modelNumber = null;
    try { 
      modelNumber = this._deviceProperties.modelNumber;
      this._lastPropertyValue.modelNumber = modelNumber;
    } 
    catch(err) {
      if (this._lastPropertyValue.modelNumber) {
        modelNumber = this._lastPropertyValues.modelNumber;
      }
    }
    if (modelNumber == null)
      modelNumber = SBString("device.info.unknown");

    return modelNumber;
  },

  _getDeviceProduct: function DIW__getDeviceProduct() {
    var productName = null;
    try { 
      productName = this._device.productName;
      this._lastPropertyValue.productName = productName; 
    } catch(err) {
      if (this._lastPropertyValue.productName) {
        productName = this._lastPropertyValue.productName;
      } 
    }
    if (productName == null)
      productName = SBString("device.info.unknown");
    return productName;
  },


  _getDeviceModelSize: function DIW__getDeviceModelSize() {
    if (this._deviceLibrary) {
      try {
        storageConverter =
          Cc["@songbirdnest.com/Songbird/Properties/UnitConverter/Storage;1"]
            .createInstance(Ci.sbIPropertyUnitConverter);
        var modelSize = this._deviceLibrary.getProperty
                               ("http://songbirdnest.com/device/1.0#capacity");
        return storageConverter.autoFormat(modelSize, -1, 1);
      } catch (err) { }
    }

    return SBString("device.info.unknown");
  },


  _getDeviceName: function DIW__getDeviceName() {
    var name = null;
    try { name = this._device.name; } catch(err) {}
    if (name == null)
      name = SBString("device.info.unknown");

    return name;
  },


  _getDeviceFriendlyName: function DIW__getDeviceFriendlyName() {
    var friendlyName = null;
    try { 
      friendlyName = this._deviceProperties.friendlyName;
      this._lastPropertyValue.friendlyName = friendlyNname; 
    } catch(err) {
      if (this._lastPropertyValue.friendlyName) {
        friendlyName = this._lastPropertyValue.friendlyName;
      }
    }
    if (friendlyName == null)
      friendlyName = SBString("device.info.unknown");

    return friendlyName;
  },


  _getDeviceSerialNumber: function DIW__getDeviceSerialNumber() {
    var serialNumber = null;
    try { 
      serialNumber = this._deviceProperties.serialNumber;
      this._lastPropertyValue.serialNumber = serialNumber; 
    } catch(err) {
      if (this._lastPropertyValue.serialNumber) {
        serialNumber = this._lastPropertyValue.serialNumber;
      }
    }
    if (serialNumber == null)
      serialNumber = SBString("device.info.unknown");

    return serialNumber;
  },


  _getDeviceVendor: function DIW__getDeviceVendor() {
    var vendorName = null;
    try { 
      vendorName = this._deviceProperties.vendorName;
      this._lastPropertyValue.vendorName = this._lastPropertyValue.vendorName; 
    } catch(err) {
      if (this._lastPropertyValue.vendorName) {
        vendorName = this._lastPropertyValue.vendorName;
      }
    }
    if (vendorName == null)
      vendorName = SBString("device.info.unknown");

    return vendorName;
  },

  _getDeviceFirmwareVersion: function DIW__getDeviceFirmwareVersion() {
    var firmwareVersion = null;
    
    var deviceFirmwareUpdater = 
      Cc["@songbirdnest.com/Songbird/Device/Firmware/Updater;1"]
        .getService(Ci.sbIDeviceFirmwareUpdater);
    
    // If we have a firmware handler for the device, use it to read
    // the device firmware version.  Don't use the device properties firmware
    // version as it will generally not match the version displayed in the
    // device UI.
    if(deviceFirmwareUpdater.hasHandler(this._device, 0, 0)) {
      var handler = deviceFirmwareUpdater.getHandler(this._device, 0, 0);
      handler.bind(this._device, null);
      
      try {
        firmwareVersion = handler.currentFirmwareReadableVersion;
      }
      catch(err) {}
      
      handler.unbind();

      if (firmwareVersion == null) {
        firmwareVersion = SBString("device.info.unknown");
      }
    }
    else {
      firmwareVersion = "";
    }

    return firmwareVersion;
  },

  _getDeviceAccessCompatibility: function DIW__getDeviceAccessCompatibility() {
    var accessCompatibility =
          this._getDeviceProperty
                 ("http://songbirdnest.com/device/1.0#accessCompatibility",
                  SBString("device.info.unknown"));
    return accessCompatibility;
  },

  _getDeviceAccessCompatibilityDesc: function DIW__getDeviceAccessCompatibilityDesc() {
    var accessCompatibility = this._getDeviceAccessCompatibility();
    if (accessCompatibility == "ro")
      accessCompatibility = SBString("device.info.read_only");
    else if (accessCompatibility == "rw")
      accessCompatibility = SBString("device.info.read_write");

    return accessCompatibility;
  },

  _getExtsForMimeType : function(aMimeType, aContentType) {
    var exts = [];
    var idx = 0;

    // Use the device capabilities utils mapping
    var devCapsUtils =
      Cc["@songbirdnest.com/Songbird/Device/DeviceCapabilitiesUtils;1"]
        .getService(Ci.sbIDeviceCapabilitiesUtils);
    var extEnum = devCapsUtils.mapContentTypeToFileExtensions(aMimeType,
                                                              aContentType);
    while (extEnum.hasMore()) {
      exts[idx++] = extEnum.getNext();
    }

    if (exts.length > 0)
      return exts;
    
    // As a fallback, use nsIMIMEService to look it up
    var mimeService = Cc["@mozilla.org/mime;1"].getService(Ci.nsIMIMEService);
    if (mimeService) {
      var mimeExtension;
      try {
        mimeExtension = mimeService.getFromTypeAndExtension(aMimeType, null)
                                   .primaryExtension;
      } catch (err) {}

      if (mimeExtension) {
        exts[idx] = SBString("device.info.mimetype." + mimeExtension, mimeExtension);
        return exts;
      }
    }

    // Fall back to mime type if all else failed.
    exts[idx] = aMimeType;
    return exts;
  },

  _getDevicePlaybackFormats: function DIW__getDevicePlaybackFormats() {
    var retFormats = [];
    var extensions = [];
    try {
      var deviceCapabilities = this._device.capabilities;
      var functionArray = deviceCapabilities.getSupportedFunctionTypes({});
      for (var functionCounter = 0;
           functionCounter < functionArray.length;
           functionCounter++)
      {
        var contentArray = deviceCapabilities.getSupportedContentTypes(
                             functionArray[functionCounter], {});
        for (var contentCounter = 0;
             contentCounter < contentArray.length;
             contentCounter++)
        {
          var mimeTypeArray = deviceCapabilities.getSupportedMimeTypes(
                              contentArray[contentCounter], {});
          if (mimeTypeArray.length > 0) {
            for each (var mimetype in mimeTypeArray) {
              var exts = this._getExtsForMimeType(mimetype,
                                                  contentArray[contentCounter]);
              for (var idx = 0; idx < exts.length; idx++) {
                let ext = exts[idx];
                if (extensions.indexOf(ext) == -1)
                  extensions.push(ext);
              }
            }
          }
        }
      }
    } catch (err) { }

    extensions.sort();
    
    return extensions.join(", ") || SBString("device.info.unknown");
  },

  _getDeviceBatteryStatus: function DIW__getDeviceBatteryStatus
                                      (aBatteryLevel,
                                       aOnBatteryPower) {
    aBatteryLevel.value = this._getDeviceProperty
                        ("http://songbirdnest.com/device/1.0#batteryLevel", 
                         -1);
    var powerSource = this._getDeviceProperty
                        ("http://songbirdnest.com/device/1.0#powerSource", 0);
    aOnBatteryPower.value = (parseInt(powerSource) ? true : false);
  },


  _supportsDeviceSpec: function DIW__supportsDeviceSpec(aDeviceSpec) {
    // Check if device supports device spec.
    switch (aDeviceSpec) {
      case "model" :
      case "capacity" :
      case "model_capacity" :
      case "product_capacity" :
      case "friendly_name" :
      case "serial_number" :
      case "vendor" :
      case "access" :
      case "playback_formats" :
      case "battery" :
      case "firmware_version" :
        return true;

      default :
        break;
    }

    return false;
  },


  _getDeviceIcon: function DIW__getDeviceIcon() {
    try {
      var uri = this._deviceProperties.iconUri;
      this._lastPropertyValue.uri = uri;
      var spec = uri.spec;
      if (uri.schemeIs("file") && /\.ico$/(spec)) {
        // try to use a suitably sized image
        spec = "moz-icon://" + spec + "?size=64";
      }
      return spec;
    } catch (err) {
      if (this._lastPropertyValue.uri) {
        return this._lastPropertyValue.uri;
      }
      // default image dictated by CSS.
      return null;
    }
  }
};