mirror of
https://repo.dactyloidae.xyz/Dactyloidae/UXP.git
synced 2026-09-07 00:08:39 +09:00
Issue #1390 - Remove secondscreen modules from toolkit
This commit is contained in:
Matt A. Tobin
Roy Tam
parent
d9ce74b9da
commit
b244d44891
4 changed files with 0 additions and 855 deletions
|
|
@ -75,9 +75,6 @@ EXTRA_JS_MODULES += [
|
|||
'RemoteSecurityUI.jsm',
|
||||
'RemoteWebProgress.jsm',
|
||||
'ResponsivenessMonitor.jsm',
|
||||
'secondscreen/PresentationApp.jsm',
|
||||
'secondscreen/RokuApp.jsm',
|
||||
'secondscreen/SimpleServiceDiscovery.jsm',
|
||||
'SelectContentHelper.jsm',
|
||||
'SelectParentHelper.jsm',
|
||||
'ServiceRequest.jsm',
|
||||
|
|
|
|||
|
|
@ -1,190 +0,0 @@
|
|||
// -*- 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;
|
||||
}
|
||||
}
|
||||
|
|
@ -1,230 +0,0 @@
|
|||
// -*- 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;
|
||||
}
|
||||
}
|
||||
|
|
@ -1,432 +0,0 @@
|
|||
// -*- 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 = Services.prefs.getCharPref("browser.casting.fixedDevices", "");
|
||||
|
||||
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();
|
||||
}
|
||||
},
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue