--- a/devtools/shared/adb/adb-client.js
+++ b/devtools/shared/adb/adb-client.js
@@ -10,45 +10,45 @@
"use strict";
const { AdbSocket } = require("./adb-socket");
const OKAY = 0x59414b4f;
const FAIL = 0x4c494146;
-let _sockets = [ ];
+const _sockets = [ ];
// Return buffer, which differs between Gecko versions
function getBuffer(aPacket) {
return aPacket.buffer ? aPacket.buffer : aPacket;
}
// @param aPacket The packet to get the length from.
// @param aIgnoreResponse True if this packet has no OKAY/FAIL.
// @return A js object { length:...; data:... }
function unpackPacket(aPacket, aIgnoreResponse) {
- let buffer = getBuffer(aPacket);
+ const buffer = getBuffer(aPacket);
console.debug("Len buffer: " + buffer.byteLength);
if (buffer.byteLength === 4 && !aIgnoreResponse) {
console.debug("Packet empty");
return { length: 0, data: "" };
}
- let lengthView = new Uint8Array(buffer, aIgnoreResponse ? 0 : 4, 4);
- let decoder = new TextDecoder();
- let length = parseInt(decoder.decode(lengthView), 16);
- let text = new Uint8Array(buffer, aIgnoreResponse ? 4 : 8, length);
+ const lengthView = new Uint8Array(buffer, aIgnoreResponse ? 0 : 4, 4);
+ const decoder = new TextDecoder();
+ const length = parseInt(decoder.decode(lengthView), 16);
+ const text = new Uint8Array(buffer, aIgnoreResponse ? 4 : 8, length);
return { length, data: decoder.decode(text) };
}
// Checks if the response is expected (defaults to OKAY).
// @return true if response equals expected.
function checkResponse(aPacket, aExpected = OKAY) {
- let buffer = getBuffer(aPacket);
- let view = new Uint32Array(buffer, 0, 1);
+ const buffer = getBuffer(aPacket);
+ const view = new Uint32Array(buffer, 0, 1);
if (view[0] == FAIL) {
console.debug("Response: FAIL");
}
console.debug("view[0] = " + view[0]);
return view[0] == aExpected;
}
// @param aCommand A protocol-level command as described in
@@ -56,34 +56,34 @@ function checkResponse(aPacket, aExpecte
// http://androidxref.com/4.0.4/xref/system/core/adb/SERVICES.TXT
// @return A 8 bit typed array.
function createRequest(aCommand) {
let length = aCommand.length.toString(16).toUpperCase();
while (length.length < 4) {
length = "0" + length;
}
- let encoder = new TextEncoder();
+ const encoder = new TextEncoder();
console.debug("Created request: " + length + aCommand);
return encoder.encode(length + aCommand);
}
function close() {
_sockets.forEach(function(s) {
s.close();
});
}
function connect() {
- let tmp = new AdbSocket();
+ const tmp = new AdbSocket();
_sockets.push(tmp);
return tmp;
}
-let client = {
+const client = {
getBuffer,
unpackPacket,
checkResponse,
createRequest,
connect,
close
};
--- a/devtools/shared/adb/adb.js
+++ b/devtools/shared/adb/adb.js
@@ -48,47 +48,47 @@ const ADB = {
this._adbFilePromise = getFileForBinary();
return this._adbFilePromise;
},
// We startup by launching adb in server mode, and setting
// the tcp socket preference to |true|
start() {
return new Promise(async (resolve, reject) => {
- let onSuccessfulStart = () => {
+ const onSuccessfulStart = () => {
Services.obs.notifyObservers(null, "adb-ready");
this.ready = true;
resolve();
};
- let isAdbRunning = await check();
+ const isAdbRunning = await check();
if (isAdbRunning) {
this.didRunInitially = false;
console.log("Found ADB process running, not restarting");
onSuccessfulStart();
return;
}
console.log("Didn't find ADB process running, restarting");
this.didRunInitially = true;
- let process = Cc["@mozilla.org/process/util;1"]
+ const process = Cc["@mozilla.org/process/util;1"]
.createInstance(Ci.nsIProcess);
// FIXME: Bug 1481691 - We should avoid extracting files every time.
- let adbFile = await this.adbFilePromise;
+ const adbFile = await this.adbFilePromise;
process.init(adbFile);
// Hide command prompt window on Windows
try {
// startHidden is 55+
process.startHidden = true;
// noShell attribute is 58+
process.noShell = true;
} catch (e) {
}
- let params = ["start-server"];
- let self = this;
+ const params = ["start-server"];
+ const self = this;
process.runAsync(params, params.length, {
observe(aSubject, aTopic, aData) {
switch (aTopic) {
case "process-finished":
onSuccessfulStart();
break;
case "process-failed":
self.ready = false;
@@ -134,37 +134,37 @@ const ADB = {
* Whether or not to kill the server synchronously. In general,
* this should be false. But on Windows, an add-on may fail to update
* if its copy of ADB is running when Firefox tries to update it.
* So add-ons who observe their own updates and kill the ADB server
* beforehand should do so synchronously on Windows to make sure
* the update doesn't race the killing.
*/
async kill(sync) {
- let process = Cc["@mozilla.org/process/util;1"]
+ const process = Cc["@mozilla.org/process/util;1"]
.createInstance(Ci.nsIProcess);
- let adbFile = await this.adbFilePromise;
+ const adbFile = await this.adbFilePromise;
process.init(adbFile);
// Hide command prompt window on Windows
try {
// startHidden is 55+
process.startHidden = true;
// noShell attribute is 58+
process.noShell = true;
} catch (e) {
}
- let params = ["kill-server"];
+ const params = ["kill-server"];
if (sync) {
process.run(true, params, params.length);
console.log("adb kill-server: " + process.exitValue);
this.ready = false;
this.didRunInitially = false;
} else {
- let self = this;
+ const self = this;
process.runAsync(params, params.length, {
observe(aSubject, aTopic, aData) {
switch (aTopic) {
case "process-finished":
console.log("adb kill-server: " + process.exitValue);
Services.obs.notifyObservers(null, "adb-killed");
self.ready = false;
self.didRunInitially = false;
@@ -184,38 +184,37 @@ const ADB = {
}
},
// Start tracking devices connecting and disconnecting from the host.
// We can't reuse runCommand here because we keep the socket alive.
// @return The socket used.
trackDevices: function adb_trackDevices() {
console.log("trackDevices");
- let socket = client.connect();
+ const socket = client.connect();
let waitForFirst = true;
- let devices = {};
+ const devices = {};
socket.s.onopen = function() {
console.log("trackDevices onopen");
Services.obs.notifyObservers(null, "adb-track-devices-start");
- let req = client.createRequest("host:track-devices");
+ const req = client.createRequest("host:track-devices");
socket.send(req);
-
};
socket.s.onerror = function(event) {
console.log("trackDevices onerror: " + event);
Services.obs.notifyObservers(null, "adb-track-devices-stop");
};
socket.s.onclose = function() {
console.log("trackDevices onclose");
// Report all devices as disconnected
- for (let dev in devices) {
+ for (const dev in devices) {
devices[dev] = false;
EventEmitter.emit(ADB, "device-disconnected", dev);
}
Services.obs.notifyObservers(null, "adb-track-devices-stop");
// When we lose connection to the server,
// and the adb is still on, we most likely got our server killed
@@ -227,78 +226,78 @@ const ADB = {
ADB.trackDevices(); // Re-track devices
});
}
}, 2000);
};
socket.s.ondata = function(aEvent) {
console.log("trackDevices ondata");
- let data = aEvent.data;
+ const data = aEvent.data;
console.log("length=" + data.byteLength);
- let dec = new TextDecoder();
+ const dec = new TextDecoder();
console.log(dec.decode(new Uint8Array(data)).trim());
// check the OKAY or FAIL on first packet.
if (waitForFirst) {
if (!client.checkResponse(data, OKAY)) {
socket.close();
return;
}
}
- let packet = client.unpackPacket(data, !waitForFirst);
+ const packet = client.unpackPacket(data, !waitForFirst);
waitForFirst = false;
if (packet.data == "") {
// All devices got disconnected.
- for (let dev in devices) {
+ for (const dev in devices) {
devices[dev] = false;
EventEmitter.emit(ADB, "device-disconnected", dev);
}
} else {
// One line per device, each line being $DEVICE\t(offline|device)
- let lines = packet.data.split("\n");
- let newDev = {};
+ const lines = packet.data.split("\n");
+ const newDev = {};
lines.forEach(function(aLine) {
if (aLine.length == 0) {
return;
}
- let [dev, status] = aLine.split("\t");
+ const [dev, status] = aLine.split("\t");
newDev[dev] = status !== "offline";
});
// Check which device changed state.
- for (let dev in newDev) {
+ for (const dev in newDev) {
if (devices[dev] != newDev[dev]) {
if (dev in devices || newDev[dev]) {
- let topic = newDev[dev] ? "device-connected"
- : "device-disconnected";
+ const topic = newDev[dev] ? "device-connected"
+ : "device-disconnected";
EventEmitter.emit(ADB, topic, dev);
}
devices[dev] = newDev[dev];
}
}
}
};
},
// Sends back an array of device names.
listDevices: function adb_listDevices() {
console.log("listDevices");
return this.runCommand("host:devices").then(
function onSuccess(data) {
- let lines = data.split("\n");
- let res = [];
+ const lines = data.split("\n");
+ const res = [];
lines.forEach(function(aLine) {
if (aLine.length == 0) {
return;
}
- let [ device ] = aLine.split("\t");
+ const [ device ] = aLine.split("\t");
res.push(device);
});
return res;
}
);
},
// sends adb forward aLocalPort aDevicePort
@@ -320,93 +319,92 @@ const ADB = {
// send STAT + hex4(path.length) + path
// recv STAT + 12 bytes (3 x 32 bits: mode, size, time)
// send RECV + hex4(path.length) + path
// while(needs data):
// recv DATA + hex4 + data
// recv DONE + hex4(0)
// send QUIT + hex4(0)
pull: function adb_pull(aFrom, aDest) {
- let deferred = PromiseUtils.defer();
- let socket;
+ const deferred = PromiseUtils.defer();
let state;
let fileData = null;
let currentPos = 0;
let chunkSize = 0;
let pkgData;
- let headerArray = new Uint32Array(2);
+ const headerArray = new Uint32Array(2);
let currentHeaderLength = 0;
- let encoder = new TextEncoder();
+ const encoder = new TextEncoder();
let infoLengthPacket;
console.log("pulling " + aFrom + " -> " + aDest);
- let shutdown = function() {
+ const shutdown = function() {
console.log("pull shutdown");
socket.close();
deferred.reject("BAD_RESPONSE");
};
// extract chunk data header info. to headerArray.
- let extractChunkDataHeader = function(data) {
- let tmpArray = new Uint8Array(headerArray.buffer);
+ const extractChunkDataHeader = function(data) {
+ const tmpArray = new Uint8Array(headerArray.buffer);
for (let i = 0; i < 8 - currentHeaderLength; i++) {
tmpArray[currentHeaderLength + i] = data[i];
}
};
// chunk data header is 8 bytes length,
// the first 4 bytes: hex4("DATA"), and
// the second 4 bytes: hex4(chunk size)
- let checkChunkDataHeader = function(data) {
+ const checkChunkDataHeader = function(data) {
if (data.length + currentHeaderLength >= 8) {
extractChunkDataHeader(data);
if (headerArray[0] != DATA) {
shutdown();
return false;
}
// remove header info. from socket package data
pkgData = data.subarray(8 - currentHeaderLength, data.length);
chunkSize = headerArray[1];
currentHeaderLength = 0;
return true;
}
// If chunk data header info. is separated into more than one
// socket package, keep partial header info. in headerArray.
- let tmpArray = new Uint8Array(headerArray.buffer);
+ const tmpArray = new Uint8Array(headerArray.buffer);
for (let i = 0; i < data.length; i++) {
tmpArray[currentHeaderLength + i] = data[i];
}
currentHeaderLength += data.length;
return true;
};
// The last remaining package data contains 8 bytes,
// they are "DONE(0x454e4f44)" and 0x0000.
- let checkDone = function(data) {
+ const checkDone = function(data) {
if (data.length != 8) {
return false;
}
- let doneFlagArray = new Uint32Array(1);
- let tmpArray = new Uint8Array(doneFlagArray.buffer);
+ const doneFlagArray = new Uint32Array(1);
+ const tmpArray = new Uint8Array(doneFlagArray.buffer);
for (let i = 0; i < 4; i++) {
tmpArray[i] = data[i];
}
// Check DONE flag
if (doneFlagArray[0] == DONE) {
return true;
}
return false;
};
- let runFSM = function runFSM(aData) {
+ const runFSM = function runFSM(aData) {
console.log("runFSM " + state);
let req;
switch (state) {
case "start":
state = "send-transport";
runFSM();
break;
case "send-transport":
@@ -472,30 +470,30 @@ const ADB = {
return;
}
if (chunkSize == 0 && !checkChunkDataHeader(pkgData)) {
shutdown();
return;
}
// handle full chunk
if (chunkSize > 0 && pkgData.length >= chunkSize) {
- let chunkData = pkgData.subarray(0, chunkSize);
- let tmpData = new Uint8Array(currentPos + chunkSize);
+ const chunkData = pkgData.subarray(0, chunkSize);
+ const tmpData = new Uint8Array(currentPos + chunkSize);
if (fileData) {
tmpData.set(fileData, 0);
}
tmpData.set(chunkData, currentPos);
fileData = tmpData;
pkgData = pkgData.subarray(chunkSize, pkgData.length);
currentPos += chunkSize;
chunkSize = 0;
}
// handle partial chunk at the end of socket package
if (chunkSize > 0 && pkgData.length > 0 && pkgData.length < chunkSize) {
- let tmpData = new Uint8Array(currentPos + pkgData.length);
+ const tmpData = new Uint8Array(currentPos + pkgData.length);
if (fileData) {
tmpData.set(fileData, 0);
}
tmpData.set(pkgData, currentPos);
fileData = tmpData;
currentPos += pkgData.length;
chunkSize -= pkgData.length;
break; // Break while loop.
@@ -516,17 +514,17 @@ const ADB = {
socket.close();
break;
default:
console.log("pull Unexpected State: " + state);
deferred.reject("UNEXPECTED_STATE");
}
};
- let setupSocket = function() {
+ const setupSocket = function() {
socket.s.onerror = function(aEvent) {
console.log("pull onerror");
deferred.reject("SOCKET_ERROR");
};
socket.s.onopen = function(aEvent) {
console.log("pull onopen");
state = "start";
@@ -538,44 +536,44 @@ const ADB = {
};
socket.s.ondata = function(aEvent) {
console.log("pull ondata:");
runFSM(aEvent.data);
};
};
- socket = client.connect();
+ const socket = client.connect();
setupSocket();
return deferred.promise;
},
// pushes a file to the device.
// aFrom and aDest are full paths.
// XXX we should STAT the remote path before sending.
push: function adb_push(aFrom, aDest) {
- let deferred = PromiseUtils.defer();
+ const deferred = PromiseUtils.defer();
let socket;
let state;
let fileSize;
let fileData;
let remaining;
let currentPos = 0;
let fileTime;
console.log("pushing " + aFrom + " -> " + aDest);
- let shutdown = function() {
+ const shutdown = function() {
console.log("push shutdown");
socket.close();
deferred.reject("BAD_RESPONSE");
};
- let runFSM = function runFSM(aData) {
+ const runFSM = function runFSM(aData) {
console.log("runFSM " + state);
let req;
switch (state) {
case "start":
state = "send-transport";
runFSM();
break;
case "send-transport":
@@ -604,46 +602,46 @@ const ADB = {
}
console.log("sync: OK");
state = "send-send";
runFSM();
break;
case "send-send":
// need to send SEND + length($aDest,$fileMode)
// $fileMode is not the octal one there.
- let encoder = new TextEncoder();
+ const encoder = new TextEncoder();
- let infoLengthPacket = new Uint32Array(1), info = aDest + ",33204";
+ const infoLengthPacket = new Uint32Array(1), info = aDest + ",33204";
infoLengthPacket[0] = info.length;
socket.send(encoder.encode("SEND"));
socket.send(infoLengthPacket);
socket.send(encoder.encode(info));
// now sending file data.
while (remaining > 0) {
- let toSend = remaining > 65536 ? 65536 : remaining;
+ const toSend = remaining > 65536 ? 65536 : remaining;
console.log("Sending " + toSend + " bytes");
- let dataLengthPacket = new Uint32Array(1);
+ const dataLengthPacket = new Uint32Array(1);
// We have to create a new ArrayBuffer for the fileData slice
// because nsIDOMTCPSocket (or ArrayBufferInputStream) chokes on
// reused buffers, even when we don't modify their contents.
- let dataPacket = new Uint8Array(new ArrayBuffer(toSend));
+ const dataPacket = new Uint8Array(new ArrayBuffer(toSend));
dataPacket.set(new Uint8Array(fileData.buffer, currentPos, toSend));
dataLengthPacket[0] = toSend;
socket.send(encoder.encode("DATA"));
socket.send(dataLengthPacket);
socket.send(dataPacket);
currentPos += toSend;
remaining -= toSend;
}
// Ending up with DONE + mtime (wtf???)
- let fileTimePacket = new Uint32Array(1);
+ const fileTimePacket = new Uint32Array(1);
fileTimePacket[0] = fileTime;
socket.send(encoder.encode("DONE"));
socket.send(fileTimePacket);
state = "wait-done";
break;
case "wait-done":
if (!client.checkResponse(aData, OKAY)) {
@@ -659,17 +657,17 @@ const ADB = {
deferred.resolve("SUCCESS");
break;
default:
console.log("push Unexpected State: " + state);
deferred.reject("UNEXPECTED_STATE");
}
};
- let setupSocket = function() {
+ const setupSocket = function() {
socket.s.onerror = function(aEvent) {
console.log("push onerror");
deferred.reject("SOCKET_ERROR");
};
socket.s.onopen = function(aEvent) {
console.log("push onopen");
state = "start";
@@ -693,17 +691,17 @@ const ADB = {
deferred.reject("CANT_PUSH_DIR");
} else {
// The path represents a file, not a directory
fileSize = stat.size;
// We want seconds since epoch
fileTime = stat.lastModificationDate.getTime() / 1000;
remaining = fileSize;
console.log(aFrom + " size is " + fileSize);
- let readPromise = OS.File.read(aFrom);
+ const readPromise = OS.File.read(aFrom);
readPromise.then(
function readSuccess(aData) {
fileData = aData;
socket = client.connect();
setupSocket();
},
function readError() {
deferred.reject("READ_FAILED");
@@ -717,78 +715,78 @@ const ADB = {
}
);
return deferred.promise;
},
// Run a shell command
shell: function adb_shell(aCommand) {
- let deferred = PromiseUtils.defer();
- let socket;
+ const deferred = PromiseUtils.defer();
let state;
let stdout = "";
console.log("shell " + aCommand);
- let shutdown = function() {
+ const shutdown = function() {
console.log("shell shutdown");
socket.close();
deferred.reject("BAD_RESPONSE");
};
- let runFSM = function runFSM(aData) {
+ const runFSM = function runFSM(aData) {
console.log("runFSM " + state);
let req;
let ignoreResponseCode = false;
switch (state) {
case "start":
state = "send-transport";
runFSM();
- break;
+ break;
case "send-transport":
req = client.createRequest("host:transport-any");
socket.send(req);
state = "wait-transport";
- break;
+ break;
case "wait-transport":
if (!client.checkResponse(aData, OKAY)) {
shutdown();
return;
}
state = "send-shell";
runFSM();
- break;
+ break;
case "send-shell":
req = client.createRequest("shell:" + aCommand);
socket.send(req);
state = "rec-shell";
- break;
+ break;
case "rec-shell":
if (!client.checkResponse(aData, OKAY)) {
shutdown();
return;
}
state = "decode-shell";
if (client.getBuffer(aData).byteLength == 4) {
break;
}
ignoreResponseCode = true;
case "decode-shell":
- let decoder = new TextDecoder();
- let text = new Uint8Array(client.getBuffer(aData), ignoreResponseCode ? 4 : 0);
+ const decoder = new TextDecoder();
+ const text = new Uint8Array(client.getBuffer(aData),
+ ignoreResponseCode ? 4 : 0);
stdout += decoder.decode(text);
- break;
+ break;
default:
console.log("shell Unexpected State: " + state);
deferred.reject("UNEXPECTED_STATE");
}
};
- socket = client.connect();
+ const socket = client.connect();
socket.s.onerror = function(aEvent) {
console.log("shell onerror");
deferred.reject("SOCKET_ERROR");
};
socket.s.onopen = function(aEvent) {
console.log("shell onopen");
state = "start";
@@ -816,64 +814,63 @@ const ADB = {
return this.shell("reboot recovery");
},
rebootBootloader: function adb_rebootBootloader() {
return this.shell("reboot bootloader");
},
root: function adb_root() {
- let deferred = PromiseUtils.defer();
- let socket;
+ const deferred = PromiseUtils.defer();
let state;
console.log("root");
- let shutdown = function() {
+ const shutdown = function() {
console.log("root shutdown");
socket.close();
deferred.reject("BAD_RESPONSE");
};
- let runFSM = function runFSM(aData) {
+ const runFSM = function runFSM(aData) {
console.log("runFSM " + state);
let req;
switch (state) {
case "start":
state = "send-transport";
runFSM();
- break;
+ break;
case "send-transport":
req = client.createRequest("host:transport-any");
socket.send(req);
state = "wait-transport";
- break;
+ break;
case "wait-transport":
if (!client.checkResponse(aData, OKAY)) {
shutdown();
return;
}
state = "send-root";
runFSM();
- break;
+ break;
case "send-root":
req = client.createRequest("root:");
socket.send(req);
state = "rec-root";
- break;
+ break;
case "rec-root":
// Nothing to do
- break;
+ break;
default:
console.log("root Unexpected State: " + state);
deferred.reject("UNEXPECTED_STATE");
}
};
- socket = client.connect();
+ const socket = client.connect();
socket.s.onerror = function(aEvent) {
console.log("root onerror");
deferred.reject("SOCKET_ERROR");
};
socket.s.onopen = function(aEvent) {
console.log("root onopen");
state = "start";
@@ -893,53 +890,53 @@ const ADB = {
return deferred.promise;
},
// Asynchronously runs an adb command.
// @param aCommand The command as documented in
// http://androidxref.com/4.0.4/xref/system/core/adb/SERVICES.TXT
runCommand: function adb_runCommand(aCommand) {
console.log("runCommand " + aCommand);
- let deferred = PromiseUtils.defer();
+ const deferred = PromiseUtils.defer();
if (!this.ready) {
- setTimeout(function() { deferred.reject("ADB_NOT_READY"); });
+ setTimeout(function() {
+ deferred.reject("ADB_NOT_READY");
+ });
return deferred.promise;
}
- let socket = client.connect();
+ const socket = client.connect();
socket.s.onopen = function() {
console.log("runCommand onopen");
- let req = client.createRequest(aCommand);
+ const req = client.createRequest(aCommand);
socket.send(req);
-
};
socket.s.onerror = function() {
console.log("runCommand onerror");
deferred.reject("NETWORK_ERROR");
};
socket.s.onclose = function() {
console.log("runCommand onclose");
};
socket.s.ondata = function(aEvent) {
console.log("runCommand ondata");
- let data = aEvent.data;
+ const data = aEvent.data;
- let packet = client.unpackPacket(data, false);
+ const packet = client.unpackPacket(data, false);
if (!client.checkResponse(data, OKAY)) {
socket.close();
console.log("Error: " + packet.data);
deferred.reject("PROTOCOL_ERROR");
return;
}
deferred.resolve(packet.data);
};
-
return deferred.promise;
}
};
exports.ADB = ADB;