From 5f8de423f190bbb79a62f804151bc24824fa32d8 Mon Sep 17 00:00:00 2001 From: "Matt A. Tobin" Date: Fri, 2 Feb 2018 04:16:08 -0500 Subject: Add m-esr52 at 52.6.0 --- toolkit/modules/secondscreen/PresentationApp.jsm | 190 +++++++++ toolkit/modules/secondscreen/RokuApp.jsm | 230 +++++++++++ .../secondscreen/SimpleServiceDiscovery.jsm | 435 +++++++++++++++++++++ 3 files changed, 855 insertions(+) create mode 100644 toolkit/modules/secondscreen/PresentationApp.jsm create mode 100644 toolkit/modules/secondscreen/RokuApp.jsm create mode 100644 toolkit/modules/secondscreen/SimpleServiceDiscovery.jsm (limited to 'toolkit/modules/secondscreen') diff --git a/toolkit/modules/secondscreen/PresentationApp.jsm b/toolkit/modules/secondscreen/PresentationApp.jsm new file mode 100644 index 000000000..b7d8e05a8 --- /dev/null +++ b/toolkit/modules/secondscreen/PresentationApp.jsm @@ -0,0 +1,190 @@ +// -*- indent-tabs-mode: nil; js-indent-level: 2 -*- +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this file, + * You can obtain one at http://mozilla.org/MPL/2.0/. */ + +"use strict"; + +this.EXPORTED_SYMBOLS = ["PresentationApp"]; + +const { classes: Cc, interfaces: Ci, utils: Cu } = Components; + +Cu.import("resource://gre/modules/Services.jsm"); +Cu.import("resource://gre/modules/XPCOMUtils.jsm"); + +XPCOMUtils.defineLazyGetter(this, "sysInfo", () => { + return Cc["@mozilla.org/system-info;1"].getService(Ci.nsIPropertyBag2); +}); + +const DEBUG = false; + +const STATE_UNINIT = "uninitialized" // RemoteMedia status +const STATE_STARTED = "started"; // RemoteMedia status +const STATE_PAUSED = "paused"; // RemoteMedia status +const STATE_SHUTDOWN = "shutdown"; // RemoteMedia status + +function debug(msg) { + Services.console.logStringMessage("PresentationApp: " + msg); +} + +// PresentationApp is a wrapper for interacting with a Presentation Receiver Device. +function PresentationApp(service, request) { + this.service = service; + this.request = request; +} + +PresentationApp.prototype = { + start: function start(callback) { + this.request.startWithDevice(this.service.uuid) + .then((session) => { + this._session = session; + if (callback) { + session.addEventListener('connect', () => { + callback(true); + }); + } + }, () => { + if (callback) { + callback(false); + } + }); + }, + + stop: function stop(callback) { + if (this._session && this._session.state === "connected") { + this._session.terminate(); + } + + delete this._session; + + if (callback) { + callback(true); + } + }, + + remoteMedia: function remoteMedia(callback, listener) { + if (callback) { + if (!this._session) { + callback(); + return; + } + + callback(new RemoteMedia(this._session, listener)); + } + } +} + +/* RemoteMedia provides a wrapper for using Presentation API to control Firefox TV app. + * The server implementation must be built into the Firefox TV receiver app. + * see https://github.com/mozilla-b2g/gaia/tree/master/tv_apps/fling-player + */ +function RemoteMedia(session, listener) { + this._session = session ; + this._listener = listener; + this._status = STATE_UNINIT; + + this._session.addEventListener("message", this); + this._session.addEventListener("terminate", this); + + if (this._listener && "onRemoteMediaStart" in this._listener) { + Services.tm.mainThread.dispatch((function() { + this._listener.onRemoteMediaStart(this); + }).bind(this), Ci.nsIThread.DISPATCH_NORMAL); + } +} + +RemoteMedia.prototype = { + _seq: 0, + + handleEvent: function(e) { + switch (e.type) { + case "message": + this._onmessage(e); + break; + case "terminate": + this._onterminate(e); + break; + } + }, + + _onmessage: function(e) { + DEBUG && debug("onmessage: " + e.data); + if (this.status === STATE_SHUTDOWN) { + return; + } + + if (e.data.indexOf("stopped") > -1) { + if (this.status !== STATE_PAUSED) { + this._status = STATE_PAUSED; + if (this._listener && "onRemoteMediaStatus" in this._listener) { + this._listener.onRemoteMediaStatus(this); + } + } + } else if (e.data.indexOf("playing") > -1) { + if (this.status !== STATE_STARTED) { + this._status = STATE_STARTED; + if (this._listener && "onRemoteMediaStatus" in this._listener) { + this._listener.onRemoteMediaStatus(this); + } + } + } + }, + + _onterminate: function(e) { + DEBUG && debug("onterminate: " + this._session.state); + this._status = STATE_SHUTDOWN; + if (this._listener && "onRemoteMediaStop" in this._listener) { + this._listener.onRemoteMediaStop(this); + } + }, + + _sendCommand: function(command, data) { + let msg = { + 'type': command, + 'seq': ++this._seq + }; + + if (data) { + for (var k in data) { + msg[k] = data[k]; + } + } + + let raw = JSON.stringify(msg); + DEBUG && debug("send command: " + raw); + + this._session.send(raw); + }, + + shutdown: function shutdown() { + DEBUG && debug("RemoteMedia - shutdown"); + this._sendCommand("close"); + }, + + play: function play() { + DEBUG && debug("RemoteMedia - play"); + this._sendCommand("play"); + }, + + pause: function pause() { + DEBUG && debug("RemoteMedia - pause"); + this._sendCommand("pause"); + }, + + load: function load(data) { + DEBUG && debug("RemoteMedia - load: " + data); + this._sendCommand("load", { "url": data.source }); + + let deviceName; + if (Services.appinfo.widgetToolkit == "android") { + deviceName = sysInfo.get("device"); + } else { + deviceName = sysInfo.get("host"); + } + this._sendCommand("device-info", { "displayName": deviceName }); + }, + + get status() { + return this._status; + } +} diff --git a/toolkit/modules/secondscreen/RokuApp.jsm b/toolkit/modules/secondscreen/RokuApp.jsm new file mode 100644 index 000000000..b37a688cd --- /dev/null +++ b/toolkit/modules/secondscreen/RokuApp.jsm @@ -0,0 +1,230 @@ +// -*- indent-tabs-mode: nil; js-indent-level: 2 -*- +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this file, + * You can obtain one at http://mozilla.org/MPL/2.0/. */ + +"use strict"; + +this.EXPORTED_SYMBOLS = ["RokuApp"]; + +const { classes: Cc, interfaces: Ci, utils: Cu } = Components; + +Cu.import("resource://gre/modules/Services.jsm"); +Cu.import("resource://gre/modules/AppConstants.jsm"); + +function log(msg) { + // Services.console.logStringMessage(msg); +} + +const PROTOCOL_VERSION = 1; + +/* RokuApp is a wrapper for interacting with a Roku channel. + * The basic interactions all use a REST API. + * spec: http://sdkdocs.roku.com/display/sdkdoc/External+Control+Guide + */ +function RokuApp(service) { + this.service = service; + this.resourceURL = this.service.location; + this.app = AppConstants.RELEASE_OR_BETA ? "Firefox" : "Firefox Nightly"; + this.mediaAppID = -1; +} + +RokuApp.prototype = { + status: function status(callback) { + // We have no way to know if the app is running, so just return "unknown" + // but we use this call to fetch the mediaAppID for the given app name + let url = this.resourceURL + "query/apps"; + let xhr = Cc["@mozilla.org/xmlextras/xmlhttprequest;1"].createInstance(Ci.nsIXMLHttpRequest); + xhr.open("GET", url, true); + xhr.channel.loadFlags |= Ci.nsIRequest.INHIBIT_CACHING; + xhr.overrideMimeType("text/xml"); + + xhr.addEventListener("load", (function() { + if (xhr.status == 200) { + let doc = xhr.responseXML; + let apps = doc.querySelectorAll("app"); + for (let app of apps) { + if (app.textContent == this.app) { + this.mediaAppID = app.id; + } + } + } + + // Since ECP has no way of telling us if an app is running, we always return "unknown" + if (callback) { + callback({ state: "unknown" }); + } + }).bind(this), false); + + xhr.addEventListener("error", (function() { + if (callback) { + callback({ state: "unknown" }); + } + }).bind(this), false); + + xhr.send(null); + }, + + start: function start(callback) { + // We need to make sure we have cached the mediaAppID + if (this.mediaAppID == -1) { + this.status(function() { + // If we found the mediaAppID, use it to make a new start call + if (this.mediaAppID != -1) { + this.start(callback); + } else { + // We failed to start the app, so let the caller know + callback(false); + } + }.bind(this)); + return; + } + + // Start a given app with any extra query data. Each app uses it's own data scheme. + // NOTE: Roku will also pass "source=external-control" as a param + let url = this.resourceURL + "launch/" + this.mediaAppID + "?version=" + parseInt(PROTOCOL_VERSION); + let xhr = Cc["@mozilla.org/xmlextras/xmlhttprequest;1"].createInstance(Ci.nsIXMLHttpRequest); + xhr.open("POST", url, true); + xhr.overrideMimeType("text/plain"); + + xhr.addEventListener("load", (function() { + if (callback) { + callback(xhr.status === 200); + } + }).bind(this), false); + + xhr.addEventListener("error", (function() { + if (callback) { + callback(false); + } + }).bind(this), false); + + xhr.send(null); + }, + + stop: function stop(callback) { + // Roku doesn't seem to support stopping an app, so let's just go back to + // the Home screen + let url = this.resourceURL + "keypress/Home"; + let xhr = Cc["@mozilla.org/xmlextras/xmlhttprequest;1"].createInstance(Ci.nsIXMLHttpRequest); + xhr.open("POST", url, true); + xhr.overrideMimeType("text/plain"); + + xhr.addEventListener("load", (function() { + if (callback) { + callback(xhr.status === 200); + } + }).bind(this), false); + + xhr.addEventListener("error", (function() { + if (callback) { + callback(false); + } + }).bind(this), false); + + xhr.send(null); + }, + + remoteMedia: function remoteMedia(callback, listener) { + if (this.mediaAppID != -1) { + if (callback) { + callback(new RemoteMedia(this.resourceURL, listener)); + } + } else if (callback) { + callback(); + } + } +} + +/* RemoteMedia provides a wrapper for using TCP socket to control Roku apps. + * The server implementation must be built into the Roku receiver app. + */ +function RemoteMedia(url, listener) { + this._url = url; + this._listener = listener; + this._status = "uninitialized"; + + let serverURI = Services.io.newURI(this._url, null, null); + this._socket = Cc["@mozilla.org/network/socket-transport-service;1"].getService(Ci.nsISocketTransportService).createTransport(null, 0, serverURI.host, 9191, null); + this._outputStream = this._socket.openOutputStream(0, 0, 0); + + this._scriptableStream = Cc["@mozilla.org/scriptableinputstream;1"].createInstance(Ci.nsIScriptableInputStream); + + this._inputStream = this._socket.openInputStream(0, 0, 0); + this._pump = Cc["@mozilla.org/network/input-stream-pump;1"].createInstance(Ci.nsIInputStreamPump); + this._pump.init(this._inputStream, -1, -1, 0, 0, true); + this._pump.asyncRead(this, null); +} + +RemoteMedia.prototype = { + onStartRequest: function(request, context) { + }, + + onDataAvailable: function(request, context, stream, offset, count) { + this._scriptableStream.init(stream); + let data = this._scriptableStream.read(count); + if (!data) { + return; + } + + let msg = JSON.parse(data); + if (this._status === msg._s) { + return; + } + + this._status = msg._s; + + if (this._listener) { + // Check to see if we are getting the initial "connected" message + if (this._status == "connected" && "onRemoteMediaStart" in this._listener) { + this._listener.onRemoteMediaStart(this); + } + + if ("onRemoteMediaStatus" in this._listener) { + this._listener.onRemoteMediaStatus(this); + } + } + }, + + onStopRequest: function(request, context, result) { + if (this._listener && "onRemoteMediaStop" in this._listener) + this._listener.onRemoteMediaStop(this); + }, + + _sendMsg: function _sendMsg(data) { + if (!data) + return; + + // Add the protocol version + data["_v"] = PROTOCOL_VERSION; + + let raw = JSON.stringify(data); + this._outputStream.write(raw, raw.length); + }, + + shutdown: function shutdown() { + this._outputStream.close(); + this._inputStream.close(); + }, + + get active() { + return (this._socket && this._socket.isAlive()); + }, + + play: function play() { + // TODO: add position support + this._sendMsg({ type: "PLAY" }); + }, + + pause: function pause() { + this._sendMsg({ type: "STOP" }); + }, + + load: function load(data) { + this._sendMsg({ type: "LOAD", title: data.title, source: data.source, poster: data.poster }); + }, + + get status() { + return this._status; + } +} diff --git a/toolkit/modules/secondscreen/SimpleServiceDiscovery.jsm b/toolkit/modules/secondscreen/SimpleServiceDiscovery.jsm new file mode 100644 index 000000000..cf9617ea1 --- /dev/null +++ b/toolkit/modules/secondscreen/SimpleServiceDiscovery.jsm @@ -0,0 +1,435 @@ +// -*- Mode: js; tab-width: 2; indent-tabs-mode: nil; js2-basic-offset: 2; js2-skip-preprocessor-directives: t; -*- +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this file, + * You can obtain one at http://mozilla.org/MPL/2.0/. */ + +"use strict"; + +this.EXPORTED_SYMBOLS = ["SimpleServiceDiscovery"]; + +const { classes: Cc, interfaces: Ci, utils: Cu } = Components; + +Cu.import("resource://gre/modules/Services.jsm"); +Cu.import("resource://gre/modules/XPCOMUtils.jsm"); +Cu.import("resource://gre/modules/Timer.jsm"); + +var log = Cu.reportError; + +XPCOMUtils.defineLazyGetter(this, "converter", function () { + let conv = Cc["@mozilla.org/intl/scriptableunicodeconverter"].createInstance(Ci.nsIScriptableUnicodeConverter); + conv.charset = "utf8"; + return conv; +}); + +// Spec information: +// https://tools.ietf.org/html/draft-cai-ssdp-v1-03 +// http://www.dial-multiscreen.org/dial-protocol-specification +const SSDP_PORT = 1900; +const SSDP_ADDRESS = "239.255.255.250"; + +const SSDP_DISCOVER_PACKET = + "M-SEARCH * HTTP/1.1\r\n" + + "HOST: " + SSDP_ADDRESS + ":" + SSDP_PORT + "\r\n" + + "MAN: \"ssdp:discover\"\r\n" + + "MX: 2\r\n" + + "ST: %SEARCH_TARGET%\r\n\r\n"; + +const SSDP_DISCOVER_ATTEMPTS = 3; +const SSDP_DISCOVER_DELAY = 500; +const SSDP_DISCOVER_TIMEOUT_MULTIPLIER = 2; +const SSDP_TRANSMISSION_INTERVAL = 1000; + +const EVENT_SERVICE_FOUND = "ssdp-service-found"; +const EVENT_SERVICE_LOST = "ssdp-service-lost"; + +/* + * SimpleServiceDiscovery manages any discovered SSDP services. It uses a UDP + * broadcast to locate available services on the local network. + */ +var SimpleServiceDiscovery = { + get EVENT_SERVICE_FOUND() { return EVENT_SERVICE_FOUND; }, + get EVENT_SERVICE_LOST() { return EVENT_SERVICE_LOST; }, + + _devices: new Map(), + _services: new Map(), + _searchSocket: null, + _searchInterval: 0, + _searchTimestamp: 0, + _searchTimeout: Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer), + _searchRepeat: Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer), + _discoveryMethods: [], + + _forceTrailingSlash: function(aURL) { + // Cleanup the URL to make it consistent across devices + try { + aURL = Services.io.newURI(aURL, null, null).spec; + } catch (e) {} + return aURL; + }, + + // nsIUDPSocketListener implementation + onPacketReceived: function(aSocket, aMessage) { + // Listen for responses from specific devices. There could be more than one + // available. + let response = aMessage.data.split("\n"); + let service = {}; + response.forEach(function(row) { + let name = row.toUpperCase(); + if (name.startsWith("LOCATION")) { + service.location = row.substr(10).trim(); + } else if (name.startsWith("ST")) { + service.target = row.substr(4).trim(); + } + }.bind(this)); + + if (service.location && service.target) { + service.location = this._forceTrailingSlash(service.location); + + // When we find a valid response, package up the service information + // and pass it on. + try { + this._processService(service); + } catch (e) {} + } + }, + + onStopListening: function(aSocket, aStatus) { + // This is fired when the socket is closed expectedly or unexpectedly. + // nsITimer.cancel() is a no-op if the timer is not active. + this._searchTimeout.cancel(); + this._searchSocket = null; + }, + + // Start a search. Make it continuous by passing an interval (in milliseconds). + // This will stop a current search loop because the timer resets itself. + // Returns the existing search interval. + search: function search(aInterval) { + let existingSearchInterval = this._searchInterval; + if (aInterval > 0) { + this._searchInterval = aInterval || 0; + this._searchRepeat.initWithCallback(this._search.bind(this), this._searchInterval, Ci.nsITimer.TYPE_REPEATING_SLACK); + } + this._search(); + return existingSearchInterval; + }, + + // Stop the current continuous search + stopSearch: function stopSearch() { + this._searchRepeat.cancel(); + }, + + _usingLAN: function() { + let network = Cc["@mozilla.org/network/network-link-service;1"].getService(Ci.nsINetworkLinkService); + return (network.linkType == Ci.nsINetworkLinkService.LINK_TYPE_WIFI || + network.linkType == Ci.nsINetworkLinkService.LINK_TYPE_ETHERNET || + network.linkType == Ci.nsINetworkLinkService.LINK_TYPE_UNKNOWN); + }, + + _search: function _search() { + // If a search is already active, shut it down. + this._searchShutdown(); + + // We only search if on local network + if (!this._usingLAN()) { + return; + } + + // Update the timestamp so we can use it to clean out stale services the + // next time we search. + this._searchTimestamp = Date.now(); + + // Look for any fixed IP devices. Some routers might be configured to block + // UDP broadcasts, so this is a way to skip discovery. + this._searchFixedDevices(); + + // Look for any devices via registered external discovery mechanism. + this._startExternalDiscovery(); + + // Perform a UDP broadcast to search for SSDP devices + let socket = Cc["@mozilla.org/network/udp-socket;1"].createInstance(Ci.nsIUDPSocket); + try { + socket.init(SSDP_PORT, false, Services.scriptSecurityManager.getSystemPrincipal()); + socket.joinMulticast(SSDP_ADDRESS); + socket.asyncListen(this); + } catch (e) { + // We were unable to create the broadcast socket. Just return, but don't + // kill the interval timer. This might work next time. + log("failed to start socket: " + e); + return; + } + + // Make the timeout SSDP_DISCOVER_TIMEOUT_MULTIPLIER times as long as the time needed to send out the discovery packets. + const SSDP_DISCOVER_TIMEOUT = this._devices.size * SSDP_DISCOVER_ATTEMPTS * SSDP_TRANSMISSION_INTERVAL * SSDP_DISCOVER_TIMEOUT_MULTIPLIER; + this._searchSocket = socket; + this._searchTimeout.initWithCallback(this._searchShutdown.bind(this), SSDP_DISCOVER_TIMEOUT, Ci.nsITimer.TYPE_ONE_SHOT); + + let data = SSDP_DISCOVER_PACKET; + + // Send discovery packets out at 1 per SSDP_TRANSMISSION_INTERVAL and send each SSDP_DISCOVER_ATTEMPTS times + // to allow for packet loss on noisy networks. + let timeout = SSDP_DISCOVER_DELAY; + for (let attempts = 0; attempts < SSDP_DISCOVER_ATTEMPTS; attempts++) { + for (let [key, device] of this._devices) { + let target = device.target; + setTimeout(function() { + let msgData = data.replace("%SEARCH_TARGET%", target); + try { + let msgRaw = converter.convertToByteArray(msgData); + socket.send(SSDP_ADDRESS, SSDP_PORT, msgRaw, msgRaw.length); + } catch (e) { + log("failed to convert to byte array: " + e); + } + }, timeout); + timeout += SSDP_TRANSMISSION_INTERVAL; + } + } + }, + + _searchFixedDevices: function _searchFixedDevices() { + let fixedDevices = null; + try { + fixedDevices = Services.prefs.getCharPref("browser.casting.fixedDevices"); + } catch (e) {} + + if (!fixedDevices) { + return; + } + + fixedDevices = JSON.parse(fixedDevices); + for (let fixedDevice of fixedDevices) { + // Verify we have the right data + if (!("location" in fixedDevice) || !("target" in fixedDevice)) { + continue; + } + + fixedDevice.location = this._forceTrailingSlash(fixedDevice.location); + + let service = { + location: fixedDevice.location, + target: fixedDevice.target + }; + + // We don't assume the fixed target is ready. We still need to ping it. + try { + this._processService(service); + } catch (e) {} + } + }, + + // Called when the search timeout is hit. We use it to cleanup the socket and + // perform some post-processing on the services list. + _searchShutdown: function _searchShutdown() { + if (this._searchSocket) { + // This will call onStopListening. + this._searchSocket.close(); + + // Clean out any stale services + for (let [key, service] of this._services) { + if (service.lastPing != this._searchTimestamp) { + this.removeService(service.uuid); + } + } + } + + this._stopExternalDiscovery(); + }, + + getSupportedExtensions: function() { + let extensions = []; + this.services.forEach(function(service) { + extensions = extensions.concat(service.extensions); + }, this); + return extensions.filter(function(extension, pos) { + return extensions.indexOf(extension) == pos; + }); + }, + + getSupportedMimeTypes: function() { + let types = []; + this.services.forEach(function(service) { + types = types.concat(service.types); + }, this); + return types.filter(function(type, pos) { + return types.indexOf(type) == pos; + }); + }, + + registerDevice: function registerDevice(aDevice) { + // We must have "id", "target" and "factory" defined + if (!("id" in aDevice) || !("target" in aDevice) || !("factory" in aDevice)) { + // Fatal for registration + throw "Registration requires an id, a target and a location"; + } + + // Only add if we don't already know about this device + if (!this._devices.has(aDevice.id)) { + this._devices.set(aDevice.id, aDevice); + } else { + log("device was already registered: " + aDevice.id); + } + }, + + unregisterDevice: function unregisterDevice(aDevice) { + // We must have "id", "target" and "factory" defined + if (!("id" in aDevice) || !("target" in aDevice) || !("factory" in aDevice)) { + return; + } + + // Only remove if we know about this device + if (this._devices.has(aDevice.id)) { + this._devices.delete(aDevice.id); + } else { + log("device was not registered: " + aDevice.id); + } + }, + + findAppForService: function findAppForService(aService) { + if (!aService || !aService.deviceID) { + return null; + } + + // Find the registration for the device + if (this._devices.has(aService.deviceID)) { + return this._devices.get(aService.deviceID).factory(aService); + } + return null; + }, + + findServiceForID: function findServiceForID(aUUID) { + if (this._services.has(aUUID)) { + return this._services.get(aUUID); + } + return null; + }, + + // Returns an array copy of the active services + get services() { + let array = []; + for (let [key, service] of this._services) { + let target = this._devices.get(service.deviceID); + service.extensions = target.extensions; + service.types = target.types; + array.push(service); + } + return array; + }, + + // Returns false if the service does not match the device's filters + _filterService: function _filterService(aService) { + // Loop over all the devices, looking for one that matches the service + for (let [key, device] of this._devices) { + // First level of match is on the target itself + if (device.target != aService.target) { + continue; + } + + // If we have no filter, everything passes + if (!("filters" in device)) { + aService.deviceID = device.id; + return true; + } + + // If all the filters pass, we have a match + let failed = false; + let filters = device.filters; + for (let filter in filters) { + if (filter in aService && aService[filter] != filters[filter]) { + failed = true; + } + } + + // We found a match, so link the service to the device + if (!failed) { + aService.deviceID = device.id; + return true; + } + } + + // We didn't find any matches + return false; + }, + + _processService: function _processService(aService) { + // Use the REST api to request more information about this service + let xhr = Cc["@mozilla.org/xmlextras/xmlhttprequest;1"].createInstance(Ci.nsIXMLHttpRequest); + xhr.open("GET", aService.location, true); + xhr.channel.loadFlags |= Ci.nsIRequest.INHIBIT_CACHING; + xhr.overrideMimeType("text/xml"); + + xhr.addEventListener("load", (function() { + if (xhr.status == 200) { + let doc = xhr.responseXML; + aService.appsURL = xhr.getResponseHeader("Application-URL"); + if (aService.appsURL && !aService.appsURL.endsWith("/")) + aService.appsURL += "/"; + aService.friendlyName = doc.querySelector("friendlyName").textContent; + aService.uuid = doc.querySelector("UDN").textContent; + aService.manufacturer = doc.querySelector("manufacturer").textContent; + aService.modelName = doc.querySelector("modelName").textContent; + + this.addService(aService); + } + }).bind(this), false); + + xhr.send(null); + }, + + // Add a service to the WeakMap, even if one already exists with this id. + // Returns true if this succeeded or false if it failed + _addService: function(service) { + // Filter out services that do not match the device filter + if (!this._filterService(service)) { + return false; + } + + let device = this._devices.get(service.target); + if (device && device.mirror) { + service.mirror = true; + } + this._services.set(service.uuid, service); + return true; + }, + + addService: function(service) { + // Only add and notify if we don't already know about this service + if (!this._services.has(service.uuid)) { + if (!this._addService(service)) { + return; + } + Services.obs.notifyObservers(null, EVENT_SERVICE_FOUND, service.uuid); + } + + // Make sure we remember this service is not stale + this._services.get(service.uuid).lastPing = this._searchTimestamp; + }, + + removeService: function(uuid) { + Services.obs.notifyObservers(null, EVENT_SERVICE_LOST, uuid); + this._services.delete(uuid); + }, + + updateService: function(service) { + if (!this._addService(service)) { + return; + } + + // Make sure we remember this service is not stale + this._services.get(service.uuid).lastPing = this._searchTimestamp; + }, + + addExternalDiscovery: function(discovery) { + this._discoveryMethods.push(discovery); + }, + + _startExternalDiscovery: function() { + for (let discovery of this._discoveryMethods) { + discovery.startDiscovery(); + } + }, + + _stopExternalDiscovery: function() { + for (let discovery of this._discoveryMethods) { + discovery.stopDiscovery(); + } + }, +} -- cgit v1.2.3