deviceSync.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-2011 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 sync widget.
//
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
//
// Device sync defs.
//
//------------------------------------------------------------------------------

// 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;

Cu.import("resource://app/jsmodules/sbLibraryUtils.jsm");
Cu.import("resource://app/jsmodules/sbProperties.jsm");
Cu.import("resource://app/jsmodules/StringUtils.jsm");

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

var DeviceSyncWidget = {
  //
  // Device sync object fields.
  //
  //   _widget                  Device sync widget.
  //   _deviceLibrary           Device library we are working with.
  //   _deviceSyncSettings      Device sync settings we are working with.
  //   _mediaSyncSettings       Device sync settings for this media type.
  //   _mediaType               Media Type this sync widget represents.
  //   _ignoreDevicePrefChanges Flag to switch off device pref listener
  //                            temporarily (to be used when we are changing the
  //                            prefs ourselves).
  //

  _widget: null,
  _deviceLibrary: null,
  _deviceSyncSettings: null,
  _mediaSyncSettings: null,
  _mediaType: null,
  _ignoreDevicePrefChanges: false,

  initialize: function DeviceSyncWidget__initialize(aWidget) {
    // Get the sync widget.
    this._widget = aWidget;

    this._mediaType = this._widget.getAttribute("contenttype") || "audio";

    // Set up some variable UI labels (these depend on the contentType)
    var syncAllLabel = this._getElement("content_auto_sync_all_radio");
    syncAllLabel.label = SBString("device.sync.sync_all.label." +
                                  this._mediaType);
    var importHeaderCheckbox = this._getElement("import_header_checkbox");
    importHeaderCheckbox.setAttribute("label",
                                      SBString("device.import.header.label." +
                                               this._mediaType));

    var syncHeaderCheckbox = this._getElement("sync_header_checkbox");
    syncHeaderCheckbox.setAttribute("label",
                                    SBString("device.sync.header.label." +
                                             this._mediaType));

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

    /* This initialize call can get made when a device is bound but the
     * deviceLibrary hasn't been bound yet, so we need to prevent it from
     * continuing and when the deviceLibrary is bound we'll get called again. */
    if (!this._deviceLibrary) {
      return;
    }

    // Initialize settings and add listeners
    this._deviceSyncSettings = this._deviceLibrary.syncSettings;
    var mediaType = this._getMediaType(this._mediaType);
    this._mediaSyncSettings = this._deviceSyncSettings
                                  .getMediaSettings(mediaType);
    this._deviceLibrary.addDeviceLibraryListener(this);

    // Listen for device events.
    var deviceEventTarget =
          this._device.QueryInterface(Ci.sbIDeviceEventTarget);
    deviceEventTarget.addEventListener(this);

    // Listen for changes to playlists.
    LibraryUtils.mainLibrary.addListener
      (this,
       false,
         Ci.sbIMediaList.LISTENER_FLAGS_ITEMADDED |
         Ci.sbIMediaList.LISTENER_FLAGS_AFTERITEMREMOVED |
         Ci.sbIMediaList.LISTENER_FLAGS_ITEMUPDATED);

    // Update the UI.
    this.update();
  },


  finalize: function DeviceSyncWidget_finalize() {
    // Remove library listener.
    LibraryUtils.mainLibrary.removeListener(this);

    // Remove the device libary listener for setting changes.
    if (this._deviceLibrary)
      this._deviceLibrary.removeDeviceLibraryListener(this);

    // Stop listening for device events.
    if (this._device) {
      var deviceEventTarget =
            this._device.QueryInterface(Ci.sbIDeviceEventTarget);
      deviceEventTarget.removeEventListener(this);
    }

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

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


  update: function DeviceSyncWidget_update() {
    // Ensure we have something to update
    if (!this._widget || this._ignoreDevicePrefChanges)
      return;

    // If there is no device library or mediaSyncSettings, hide the widget and
    // return.  Otherwise, show the widget.
    if (!this._deviceLibrary || !this._mediaSyncSettings) {
      this._widget.setAttribute("hidden", "true");
      return;
    }
    this._widget.removeAttribute("hidden");


    // If we are busy then disable the widget so the user can not make changes
    if (this._device.isBusy) {
      this._widget.setAttribute("disabled", true);
    }
    else {
      this._widget.removeAttribute("disabled");
    }

    // Show the video duration column only for the Video tab.
    var syncPlaylistListVideoHeader =
      this._getElement("content_auto_sync_playlist_duration");
    syncPlaylistListVideoHeader.hidden = (this._mediaType != "video");

    // Set up the playlists
    var syncPlaylistChildren = this._getElement("content_auto_sync_playlist_children");

    /* Clear the sync playlist tree. */
    while (syncPlaylistChildren.firstChild)
        syncPlaylistChildren.removeChild(syncPlaylistChildren.firstChild);

    // Get an nsIArray of available playlists for this media type
    var syncPlayLists = this._mediaSyncSettings.syncPlaylists;
    for (var listIndex = 0; listIndex < syncPlayLists.length; listIndex++) {
      var mediaList = syncPlayLists.queryElementAt(listIndex, Ci.sbIMediaList);

      // Load up the information we need
      var guid = mediaList.guid;

      // Duration only applies to video tab so don't waste time on other types
      var duration = -1;
      if (this._mediaType == "video")
        duration = this._syncPrefsCalcDuration(mediaList);

      if (duration >= 0) {
        var durationInfo =
              Cc["@songbirdnest.com/Songbird/Properties/Info/Duration;1"]
                .createInstance(Ci.sbIDurationPropertyInfo);
        duration = durationInfo.format(duration);
      }
      else {
        duration = SBString("device.sync.duration.unavailable");
      }

      // Get the readable name of this list (add mix for mix lists)
      var readableName = mediaList.name;
      var listType = mediaList.getListContentType();
      if (listType == Ci.sbIMediaList.CONTENTTYPE_MIX)
        readableName = SBFormattedString("device.sync.mix." + this._mediaType,
                                         [ readableName ]);

      /* Create our tree row */
      var treeItem = document.createElementNS(XUL_NS, "treeitem");
      var treeRow = document.createElementNS(XUL_NS, "treerow");
      var treeCellCheck = document.createElementNS(XUL_NS, "treecell");
      var treeCellTitle = document.createElementNS(XUL_NS, "treecell");
      var treeCellDuration = document.createElementNS(XUL_NS, "treecell");

      /* Set the value of this row to the guid of the media list */
      treeRow.value = guid;

      /* Setup the cells */
      /* Check box (only editable cell) */
      var isSelected = this._mediaSyncSettings.getPlaylistSelected(mediaList);
      treeCellCheck.setAttribute("value", isSelected);
      treeCellCheck.setAttribute("sbid",
                                 "content_sync_playlist_checkcell." + guid);

      /* Title of the playlist */
      treeCellTitle.setAttribute("label", readableName);
      treeCellTitle.setAttribute("editable", "false");

      /* Duration of all the _mediaType conent in the playlist */
      treeCellDuration.setAttribute("label", duration);
      treeCellDuration.setAttribute("editable", "false");

      /* Append the cells to the row */
      treeRow.appendChild(treeCellCheck);
      treeRow.appendChild(treeCellTitle);
      treeRow.appendChild(treeCellDuration);

      /* Append the row to the tree item */
      treeItem.appendChild(treeRow);

      /* Add the row to the tree. */
      syncPlaylistChildren.appendChild(treeItem);
    }

    /* Get the management type pref UI elements. */
    var syncRadioGroup = this._getElement("content_auto_sync_type_radio_group");
    var syncPlaylistTree = this._getElement("content_auto_sync_playlist_tree");
    var importEnabledCheckbox = this._getElement("import_header_checkbox");
    var syncEnabledCheckbox = this._getElement("sync_header_checkbox");
    var syncGroupbox = this._getElement("content_management_groupbox");

    /* Make the importEnabledCheckbox reflect whether this mediatype is
     * currently set to be imported or not */
    importEnabledCheckbox.checked = this._mediaSyncSettings.import;

    switch (this._mediaSyncSettings.mgmtType) {
    case Ci.sbIDeviceLibraryMediaSyncSettings.SYNC_MGMT_NONE:
      syncEnabledCheckbox.checked = false;
      syncPlaylistTree.setAttribute("disabled", true);
      syncRadioGroup.setAttribute("disabled", true);
      syncGroupbox.setAttribute("disabled", true);
      syncRadioGroup.selectedItem = null;
      break;

    case Ci.sbIDeviceLibraryMediaSyncSettings.SYNC_MGMT_ALL:
      syncEnabledCheckbox.checked = true;
      syncPlaylistTree.setAttribute("disabled", true);
      syncRadioGroup.removeAttribute("disabled");
      syncGroupbox.removeAttribute("disabled");
      syncRadioGroup.selectedItem = this._getElement
                                        ("content_auto_sync_all_radio");
      break;

    case Ci.sbIDeviceLibraryMediaSyncSettings.SYNC_MGMT_PLAYLISTS:
      syncEnabledCheckbox.checked = true;
      syncPlaylistTree.removeAttribute("disabled");
      syncRadioGroup.removeAttribute("disabled");
      syncGroupbox.removeAttribute("disabled");
      syncRadioGroup.selectedItem = this._getElement
                                        ("content_auto_sync_selected_radio");
      break;
    }

  },


  //----------------------------------------------------------------------------
  //
  // Device sync event handler services.
  //
  //----------------------------------------------------------------------------

  onUIPrefChange: function DeviceSyncWidget_onUIPrefChange(aNeedUpdate) {
    // Ignore user interaction if the widget is disabled.
    if (this._widget.hasAttribute("disabled"))
      return;

    // Ensure we do not update in the middle of updating the settings.
    this._ignoreDevicePrefChanges = true;

    var syncRadioGroup = this._getElement("content_auto_sync_type_radio_group");
    var importEnabledCheckbox = this._getElement("import_header_checkbox");
    var syncEnabledCheckbox = this._getElement("sync_header_checkbox");

    // Activate or deactivate imporpy from device depending on checkbox setting
    this._mediaSyncSettings.import = importEnabledCheckbox.checked;

    // First check the managementMode, we need to check the main check box and
    // the radio group
    var oldMgmtType = this._mediaSyncSettings.mgmtType;
    var newMgmtType = Ci.sbIDeviceLibraryMediaSyncSettings.SYNC_MGMT_NONE;

    // If sync is enabled, figure out the mgmtType between playlists and all
    if (syncEnabledCheckbox.checked) {
      /* Video only does sync by playlist and if all or playlist sync is
       * selected we can just go with that one. */
      if ((this._mediaType == "video") ||
          (syncRadioGroup.selectedItem ==
           this._getElement("content_auto_sync_selected_radio"))) {
        newMgmtType = Ci.sbIDeviceLibraryMediaSyncSettings.SYNC_MGMT_PLAYLISTS;
      }
      else if (syncRadioGroup.selectedItem ==
                this._getElement("content_auto_sync_all_radio")) {
        newMgmtType = Ci.sbIDeviceLibraryMediaSyncSettings.SYNC_MGMT_ALL;
      }
      else {
        /* If nothing is selected then we set the mgmtType to the last
         * not 'NONE' mgmtType used.  This will default to ALL */
        newMgmtType = this._mediaSyncSettings.lastActiveMgmtType;
      }
    }

    if (oldMgmtType != newMgmtType) {
      this._mediaSyncSettings.mgmtType = newMgmtType;
    }

    if (this._mediaSyncSettings.mgmtType ==
          Ci.sbIDeviceLibraryMediaSyncSettings.SYNC_MGMT_PLAYLISTS) {
      // Clear the playlists before we set them
      this._mediaSyncSettings.clearSelectedPlaylists();

      // Now scan all the playlists in the list of playlists
      var syncPlayLists = this._mediaSyncSettings.syncPlaylists;
      for (var listIndex = 0; listIndex < syncPlayLists.length; listIndex++) {
        var mediaList = syncPlayLists.queryElementAt(listIndex,
                                                     Ci.sbIMediaList);
        if (mediaList) {
          var guid = mediaList.guid;
          var treeCellCheck = this._getElement(
                                    "content_sync_playlist_checkcell." + guid);
          if (treeCellCheck) {
            // Get the new value
            var isSelected = (treeCellCheck.getAttribute("value") == "true");
            // First see if it is already set to the same value
            var oldSelected = this._mediaSyncSettings
                                  .getPlaylistSelected(mediaList);
            // Now set it if changed
            if (oldSelected != isSelected)
              this._mediaSyncSettings.setPlaylistSelected(mediaList,
                                                          isSelected);
          }
        }
      }
    }

    /* Writes the new syncSettings to a device-specific pref so that they can be
     * recalled between sessions */
    this._deviceSyncSettings.write(this._device);

    this._ignoreDevicePrefChanges = false;
    if (aNeedUpdate) {
      // Finally update to ensure it all applied
      this.update();
    }
  },

  //----------------------------------------------------------------------------
  //
  // sbIDeviceLibraryListener
  //
  //----------------------------------------------------------------------------

  // Implementation of sbIDeviceLibraryListener methods that must return true to
  // prevent SB_NOTIFY_LISTENERS_ASK_PERMISSION in sbDeviceLibrary.cpp from
  // aborting erroneously.

  onBeforeCreateMediaItem: function DeviceSyncWidget_onBeforeCreateMediaItem(
                                      aContentUri,
                                      aProperties,
                                      aAllowDuplicates) {
    return true;
  },

  onBeforeCreateMediaList: function DeviceSyncWidget_onBeforeCreateMediaList(
                                      aType,
                                      aProperties) {
    return true;
  },

  onBeforeAdd: function DeviceSyncWidget_onBeforeAdd(aMediaItem) {
    return true;
  },

  onBeforeAddAll: function DeviceSyncWidget_onBeforeAddAll(aMediaList) {
    return true;
  },

  onBeforeAddSome: function DeviceSyncWidget_onBeforeAddSome(aMediaItems) {
    return true;
  },

  onBeforeClear: function DeviceSyncWidget_onBeforeClear() {
    return true;
  },

  //----------------------------------------------------------------------------
  //
  // Device sync sbIDeviceEventListener services.
  //
  //----------------------------------------------------------------------------

  onDeviceEvent: function DeviceSyncWidget_onDeviceEvent(aEvent) {
    // Dispatch processing of the event.
    switch(aEvent.type)
    {
      case Ci.sbIDeviceEvent.EVENT_DEVICE_PREFS_CHANGED:
      case Ci.sbIDeviceEvent.EVENT_DEVICE_STATE_CHANGED:
      case Ci.sbIDeviceEvent.EVENT_DEVICE_MOUNTING_END:
        this.update();
        break;

      default :
        break;
    }
  },


  //----------------------------------------------------------------------------
  //
  // Device sync sbIMediaListListener services.
  //
  //----------------------------------------------------------------------------

  onItemAdded: function DeviceSyncWidget_onItemAdded(aMediaList,
                                                     aMediaItem,
                                                     aIndex) {
    // Handle unhidden playlist changes.
    if (aMediaItem.getProperty(SBProperties.isList) &&
        !aMediaItem.getProperty(SBProperties.hidden)) {
      this.update();
    }

    return false;
  },


  onBeforeItemRemoved: function DeviceSyncWidget_onBeforeItemRemoved
                                  (aMediaList,
                                   aMediaItem,
                                   aIndex) {
    return true;
  },


  onAfterItemRemoved: function DeviceSyncWidget_onAfterItemRemoved
                                 (aMediaList,
                                  aMediaItem,
                                  aIndex) {
    // Handle playlist changes.
    if (aMediaItem.getProperty(SBProperties.isList))
      this.update();

    return false;
  },


  onItemUpdated: function DeviceSyncWidget_onItemUpdated(aMediaList,
                                                         aMediaItem,
                                                         aProperties) {
    // Handle playlist changes.
    if (aMediaItem instanceof Ci.sbIMediaList)
      this.update();

    return false;
  },

  onBeforeListCleared:
    function DeviceSyncWidget_onBeforeListCleared(aMediaList,
                                                  aExcludeLists) {
    return true;
  },

  onListCleared: function DeviceSyncWidget_onListCleared(aMediaList,
                                                         aExcludeLists) {
    // Handle playlist changes.
    if (aExcludeLists)
      this.update();

    return false;
  },


  onBatchBegin: function DeviceSyncWidget_onBatchBegin(aMediaList) {},


  onBatchEnd: function DeviceSyncWidget_onBatchEnd(aMediaList) {},


  //----------------------------------------------------------------------------
  //
  // Device sync XUL services.
  //
  //----------------------------------------------------------------------------

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

  /*
   * \brief get the ID of media type out of the media type string
   *
   * \param aMediaType           media type string
   *
   */

  _getMediaType: function DeviceSyncWidget__getMediaType(aMediaType)
  {
    var mediaType = Ci.sbIDeviceLibrary.MEDIATYPE_UNKOWN;
    if (aMediaType == "audio")
      mediaType = Ci.sbIDeviceLibrary.MEDIATYPE_AUDIO;
    else if (aMediaType == "video")
      mediaType = Ci.sbIDeviceLibrary.MEDIATYPE_VIDEO;

    return mediaType;
  },

  _syncPrefsCalcDuration:
    function DeviceSyncWidget__syncPrefsCalcDuration(aMediaList) {
    // sbIMediaListEnumerationListener
    // This gives us a count and duration of items of contentType
    var contentDuration = -1;
    var durationCounter = {
      onEnumerationBegin : function(aMediaList) {
        return Ci.sbIMediaListEnumerationListener.CONTINUE;
      },
      onEnumeratedItem : function(aMediaList, aMediaItem) {
        var duration = aMediaItem.getProperty(SBProperties.duration);
        if (duration != null) {
          contentDuration += parseFloat(duration);
        }
        return Ci.sbIMediaListEnumerationListener.CONTINUE;
      },
      onEnumerationEnd : function(aMediaList, aStatusCode) {
      }
    };

    aMediaList.enumerateItemsByProperty(SBProperties.contentType,
                                        this._mediaType,
                                        durationCounter,
                                        Ci.sbIMediaList
                                          .ENUMERATIONTYPE_SNAPSHOT);

    return contentDuration;
  },

  //----------------------------------------------------------------------------
  //
  // Device sync 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.  In particular, these services
  //   register to receive notifications when the device state changes.
  //
  //----------------------------------------------------------------------------

  //
  // Device info services fields.
  //
  //   _device                  sbIDevice object.
  //

  _device: null,

  _deviceFinalize: function DeviceSyncWidget__deviceFinalize() {
    // Clear object fields.
    this._device = null;
  }
};