mirror of
https://github.com/classilla/tenfourfox.git
synced 2024-09-10 11:54:40 +00:00
846 lines
26 KiB
JavaScript
846 lines
26 KiB
JavaScript
/* Copyright 2012 Mozilla Foundation and Mozilla contributors
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
/* Copyright © 2013, Deutsche Telekom, Inc. */
|
|
|
|
"use strict";
|
|
|
|
const {classes: Cc, interfaces: Ci, utils: Cu, results: Cr} = Components;
|
|
|
|
Cu.import("resource://gre/modules/XPCOMUtils.jsm");
|
|
Cu.import("resource://gre/modules/Services.jsm");
|
|
|
|
XPCOMUtils.defineLazyServiceGetter(this, "gSettingsService",
|
|
"@mozilla.org/settingsService;1",
|
|
"nsISettingsService");
|
|
|
|
XPCOMUtils.defineLazyGetter(this, "NFC", function () {
|
|
let obj = {};
|
|
Cu.import("resource://gre/modules/nfc_consts.js", obj);
|
|
return obj;
|
|
});
|
|
|
|
Cu.import("resource://gre/modules/systemlibs.js");
|
|
const NFC_ENABLED = libcutils.property_get("ro.moz.nfc.enabled", "false") === "true";
|
|
|
|
// set to true in nfc_consts.js to see debug messages
|
|
var DEBUG = NFC.DEBUG_NFC;
|
|
|
|
var debug;
|
|
function updateDebug() {
|
|
if (DEBUG || NFC.DEBUG_NFC) {
|
|
debug = function (s) {
|
|
dump("-*- Nfc: " + s + "\n");
|
|
};
|
|
} else {
|
|
debug = function (s) {};
|
|
}
|
|
};
|
|
updateDebug();
|
|
|
|
const NFC_CONTRACTID = "@mozilla.org/nfc;1";
|
|
const NFC_CID =
|
|
Components.ID("{2ff24790-5e74-11e1-b86c-0800200c9a66}");
|
|
|
|
const NFC_IPC_MSG_ENTRIES = [
|
|
{ permission: null,
|
|
messages: ["NFC:AddEventListener",
|
|
"NFC:RemoveEventListener",
|
|
"NFC:QueryInfo",
|
|
"NFC:CallDefaultFoundHandler",
|
|
"NFC:CallDefaultLostHandler"] },
|
|
|
|
{ permission: "nfc",
|
|
messages: ["NFC:ReadNDEF",
|
|
"NFC:WriteNDEF",
|
|
"NFC:MakeReadOnly",
|
|
"NFC:Format",
|
|
"NFC:Transceive"] },
|
|
|
|
{ permission: "nfc-share",
|
|
messages: ["NFC:SendFile",
|
|
"NFC:RegisterPeerReadyTarget",
|
|
"NFC:UnregisterPeerReadyTarget"] },
|
|
|
|
{ permission: "nfc-manager",
|
|
messages: ["NFC:CheckP2PRegistration",
|
|
"NFC:NotifyUserAcceptedP2P",
|
|
"NFC:NotifySendFileStatus",
|
|
"NFC:ChangeRFState",
|
|
"NFC:SetFocusTab"] }
|
|
];
|
|
|
|
// Should be consistent with NfcRequestType defined in NfcOptions.webidl.
|
|
const NfcRequestType = {
|
|
CHANGE_RF_STATE: "changeRFState",
|
|
READ_NDEF: "readNDEF",
|
|
WRITE_NDEF: "writeNDEF",
|
|
MAKE_READ_ONLY: "makeReadOnly",
|
|
FORMAT: "format",
|
|
TRANSCEIVE: "transceive"
|
|
};
|
|
|
|
const CommandMsgTable = {};
|
|
CommandMsgTable["NFC:ChangeRFState"] = NfcRequestType.CHANGE_RF_STATE;
|
|
CommandMsgTable["NFC:ReadNDEF"] = NfcRequestType.READ_NDEF;
|
|
CommandMsgTable["NFC:WriteNDEF"] = NfcRequestType.WRITE_NDEF;
|
|
CommandMsgTable["NFC:MakeReadOnly"] = NfcRequestType.MAKE_READ_ONLY;
|
|
CommandMsgTable["NFC:Format"] = NfcRequestType.FORMAT;
|
|
CommandMsgTable["NFC:Transceive"] = NfcRequestType.TRANSCEIVE;
|
|
|
|
// Should be consistent with NfcResponseType defined in NfcOptions.webidl.
|
|
const NfcResponseType = {
|
|
CHANGE_RF_STATE_RSP: "changeRFStateRsp",
|
|
READ_NDEF_RSP: "readNDEFRsp",
|
|
WRITE_NDEF_RSP: "writeNDEFRsp",
|
|
MAKE_READ_ONLY_RSP: "makeReadOnlyRsp",
|
|
FORMAT_RSP: "formatRsp",
|
|
TRANSCEIVE_RSP: "transceiveRsp",
|
|
};
|
|
|
|
const EventMsgTable = {};
|
|
EventMsgTable[NfcResponseType.CHANGE_RF_STATE_RSP] = "NFC:ChangeRFStateResponse";
|
|
EventMsgTable[NfcResponseType.READ_NDEF_RSP] = "NFC:ReadNDEFResponse";
|
|
EventMsgTable[NfcResponseType.WRITE_NDEF_RSP] = "NFC:WriteNDEFResponse";
|
|
EventMsgTable[NfcResponseType.MAKE_READ_ONLY_RSP] = "NFC:MakeReadOnlyResponse";
|
|
EventMsgTable[NfcResponseType.FORMAT_RSP] = "NFC:FormatResponse";
|
|
EventMsgTable[NfcResponseType.TRANSCEIVE_RSP] = "NFC:TransceiveResponse";
|
|
|
|
// Should be consistent with NfcNotificationType defined in NfcOptions.webidl.
|
|
const NfcNotificationType = {
|
|
INITIALIZED: "initialized",
|
|
TECH_DISCOVERED: "techDiscovered",
|
|
TECH_LOST: "techLost",
|
|
HCI_EVENT_TRANSACTION: "hciEventTransaction",
|
|
NDEF_RECEIVED: "ndefReceived"
|
|
};
|
|
|
|
XPCOMUtils.defineLazyServiceGetter(this, "ppmm",
|
|
"@mozilla.org/parentprocessmessagemanager;1",
|
|
"nsIMessageBroadcaster");
|
|
XPCOMUtils.defineLazyServiceGetter(this, "gSystemMessenger",
|
|
"@mozilla.org/system-message-internal;1",
|
|
"nsISystemMessagesInternal");
|
|
XPCOMUtils.defineLazyServiceGetter(this, "UUIDGenerator",
|
|
"@mozilla.org/uuid-generator;1",
|
|
"nsIUUIDGenerator");
|
|
XPCOMUtils.defineLazyGetter(this, "gMessageManager", function () {
|
|
return {
|
|
QueryInterface: XPCOMUtils.generateQI([Ci.nsIMessageListener,
|
|
Ci.nsIObserver]),
|
|
|
|
nfc: null,
|
|
|
|
// Manage registered Peer Targets
|
|
peerTargets: {},
|
|
|
|
eventListeners: {},
|
|
|
|
focusId: NFC.SYSTEM_APP_ID,
|
|
|
|
init: function init(nfc) {
|
|
this.nfc = nfc;
|
|
|
|
if (!NFC.DEBUG_NFC) {
|
|
let lock = gSettingsService.createLock();
|
|
lock.get(NFC.SETTING_NFC_DEBUG, this.nfc);
|
|
Services.obs.addObserver(this, NFC.TOPIC_MOZSETTINGS_CHANGED, false);
|
|
}
|
|
|
|
Services.obs.addObserver(this, NFC.TOPIC_XPCOM_SHUTDOWN, false);
|
|
this._registerMessageListeners();
|
|
},
|
|
|
|
_shutdown: function _shutdown() {
|
|
this.nfc.shutdown();
|
|
this.nfc = null;
|
|
|
|
Services.obs.removeObserver(this, NFC.TOPIC_MOZSETTINGS_CHANGED);
|
|
Services.obs.removeObserver(this, NFC.TOPIC_XPCOM_SHUTDOWN);
|
|
this._unregisterMessageListeners();
|
|
},
|
|
|
|
_registerMessageListeners: function _registerMessageListeners() {
|
|
ppmm.addMessageListener("child-process-shutdown", this);
|
|
|
|
for (let entry of NFC_IPC_MSG_ENTRIES) {
|
|
for (let message of entry.messages) {
|
|
ppmm.addMessageListener(message, this);
|
|
}
|
|
}
|
|
},
|
|
|
|
_unregisterMessageListeners: function _unregisterMessageListeners() {
|
|
ppmm.removeMessageListener("child-process-shutdown", this);
|
|
|
|
for (let entry of NFC_IPC_MSG_ENTRIES) {
|
|
for (let message of entry.messages) {
|
|
ppmm.removeMessageListener(message, this);
|
|
}
|
|
}
|
|
|
|
ppmm = null;
|
|
},
|
|
|
|
registerPeerReadyTarget: function registerPeerReadyTarget(target, appId) {
|
|
if (!this.peerTargets[appId]) {
|
|
this.peerTargets[appId] = target;
|
|
}
|
|
},
|
|
|
|
unregisterPeerReadyTarget: function unregisterPeerReadyTarget(appId) {
|
|
if (this.peerTargets[appId]) {
|
|
delete this.peerTargets[appId];
|
|
}
|
|
},
|
|
|
|
removePeerTarget: function removePeerTarget(target) {
|
|
Object.keys(this.peerTargets).forEach((appId) => {
|
|
if (this.peerTargets[appId] === target) {
|
|
delete this.peerTargets[appId];
|
|
}
|
|
});
|
|
},
|
|
|
|
notifyFocusTab: function notifyFocusTab(options) {
|
|
let tabId = this.getFocusTabId();
|
|
options.tabId = tabId;
|
|
|
|
this.notifyDOMEvent(this.eventListeners[tabId], options);
|
|
},
|
|
|
|
notifyDOMEvent: function notifyDOMEvent(target, options) {
|
|
if (!target) {
|
|
dump("invalid target");
|
|
return;
|
|
}
|
|
|
|
target.sendAsyncMessage("NFC:DOMEvent", options);
|
|
},
|
|
|
|
getFocusTabId: function getFocusTabId() {
|
|
return this.eventListeners[this.focusId] ? this.focusId
|
|
: NFC.SYSTEM_APP_ID;
|
|
},
|
|
|
|
setFocusTab: function setFocusTab(id, isFocus) {
|
|
// if calling setNFCFocus(true) on the browser-element which is already
|
|
// focused, or calling setNFCFocus(false) on the browser-element which has
|
|
// lost focus already, ignore.
|
|
if (isFocus == (id == this.focusId)) {
|
|
return;
|
|
}
|
|
|
|
if (this.focusId != NFC.SYSTEM_APP_ID) {
|
|
this.onFocusChanged(this.focusId, false);
|
|
}
|
|
|
|
if (isFocus) {
|
|
// Now we only support one focus app.
|
|
this.focusId = id;
|
|
this.onFocusChanged(this.focusId, true);
|
|
} else if (this.focusId == id){
|
|
// Set focusId to SystemApp means currently there is no foreground app.
|
|
this.focusId = NFC.SYSTEM_APP_ID;
|
|
}
|
|
},
|
|
|
|
addEventListener: function addEventListener(target, id) {
|
|
if (this.eventListeners[id] !== undefined) {
|
|
return;
|
|
}
|
|
|
|
this.eventListeners[id] = target;
|
|
},
|
|
|
|
removeEventListener: function removeEventListener(target) {
|
|
for (let id in this.eventListeners) {
|
|
if (target == this.eventListeners[id]) {
|
|
this.removeEventListenerById(id);
|
|
break;
|
|
}
|
|
}
|
|
},
|
|
|
|
removeEventListenerById: function removeEventListenerById(id) {
|
|
delete this.eventListeners[id];
|
|
},
|
|
|
|
checkP2PRegistration: function checkP2PRegistration(message) {
|
|
let target = this.peerTargets[message.data.appId];
|
|
let sessionToken = SessionHelper.getCurrentP2PToken();
|
|
let isValid = (sessionToken != null) && (target != null);
|
|
let respMsg = { requestId: message.data.requestId };
|
|
if (!isValid) {
|
|
respMsg.errorMsg = this.nfc.getErrorMessage(NFC.NFC_GECKO_ERROR_P2P_REG_INVALID);
|
|
}
|
|
// Notify the content process immediately of the status
|
|
message.target.sendAsyncMessage(message.name + "Response", respMsg);
|
|
},
|
|
|
|
notifyUserAcceptedP2P: function notifyUserAcceptedP2P(appId) {
|
|
let target = this.peerTargets[appId];
|
|
let sessionToken = SessionHelper.getCurrentP2PToken();
|
|
if (!sessionToken || !target) {
|
|
debug("Peer already lost or " + appId + " is not a registered PeerReadytarget");
|
|
return;
|
|
}
|
|
|
|
this.notifyDOMEvent(target, {tabId: this.getFocusTabId(),
|
|
event: NFC.PEER_EVENT_READY,
|
|
sessionToken: sessionToken});
|
|
},
|
|
|
|
notifySendFileStatus: function notifySendFileStatus(message) {
|
|
if (message.data.status) {
|
|
message.data.errorMsg =
|
|
this.nfc.getErrorMessage(NFC.NFC_GECKO_ERROR_SEND_FILE_FAILED);
|
|
}
|
|
this.nfc.sendFileStatusResponse(message.data);
|
|
},
|
|
|
|
callDefaultFoundHandler: function callDefaultFoundHandler(message) {
|
|
let sysMsg = new NfcTechDiscoveredSysMsg(message.sessionToken,
|
|
message.isP2P,
|
|
message.records || null);
|
|
gSystemMessenger.broadcastMessage("nfc-manager-tech-discovered", sysMsg);
|
|
},
|
|
|
|
callDefaultLostHandler: function callDefaultLostHandler(message) {
|
|
// message.isP2P is not used.
|
|
gSystemMessenger.broadcastMessage("nfc-manager-tech-lost", message.sessionToken);
|
|
},
|
|
|
|
onTagFound: function onTagFound(message) {
|
|
message.event = NFC.TAG_EVENT_FOUND;
|
|
this.notifyFocusTab(message);
|
|
delete message.event;
|
|
},
|
|
|
|
onTagLost: function onTagLost(sessionToken) {
|
|
this.notifyFocusTab({ event: NFC.TAG_EVENT_LOST,
|
|
sessionToken: sessionToken });
|
|
},
|
|
|
|
onPeerEvent: function onPeerEvent(eventType, sessionToken) {
|
|
this.notifyFocusTab({ event: eventType,
|
|
sessionToken: sessionToken });
|
|
},
|
|
|
|
onRFStateChanged: function onRFStateChanged(rfState) {
|
|
for (let id in this.eventListeners) {
|
|
this.notifyDOMEvent(this.eventListeners[id],
|
|
{ tabId: id,
|
|
event: NFC.RF_EVENT_STATE_CHANGED,
|
|
rfState: rfState });
|
|
}
|
|
},
|
|
|
|
onFocusChanged: function onFocusChanged(focusId, focus) {
|
|
let target = this.eventListeners[focusId];
|
|
if (!target) {
|
|
return;
|
|
}
|
|
|
|
this.notifyDOMEvent(target, { tabId: this.focusId,
|
|
event: NFC.FOCUS_CHANGED,
|
|
focus: focus });
|
|
},
|
|
|
|
/**
|
|
* nsIMessageListener interface methods.
|
|
*/
|
|
|
|
receiveMessage: function receiveMessage(message) {
|
|
DEBUG && debug("Received message from content process: " + JSON.stringify(message));
|
|
|
|
if (message.name == "child-process-shutdown") {
|
|
this.removePeerTarget(message.target);
|
|
this.nfc.removeTarget(message.target);
|
|
this.removeEventListener(message.target);
|
|
return null;
|
|
}
|
|
|
|
for (let entry of NFC_IPC_MSG_ENTRIES) {
|
|
if (entry.messages.indexOf(message.name) != -1) {
|
|
if (entry.permission &&
|
|
!message.target.assertPermission(entry.permission)) {
|
|
debug("Nfc message " + message.name + "doesn't have " +
|
|
entry.permission + " permission.");
|
|
return null;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
switch (message.name) {
|
|
case "NFC:SetFocusTab":
|
|
this.setFocusTab(message.data.tabId, message.data.isFocus);
|
|
return null;
|
|
case "NFC:AddEventListener":
|
|
this.addEventListener(message.target, message.data.tabId);
|
|
return null;
|
|
case "NFC:RemoveEventListener":
|
|
this.removeEventListenerById(message.data.tabId);
|
|
return null;
|
|
case "NFC:RegisterPeerReadyTarget":
|
|
this.registerPeerReadyTarget(message.target, message.data.appId);
|
|
return null;
|
|
case "NFC:UnregisterPeerReadyTarget":
|
|
this.unregisterPeerReadyTarget(message.data.appId);
|
|
return null;
|
|
case "NFC:CheckP2PRegistration":
|
|
this.checkP2PRegistration(message);
|
|
return null;
|
|
case "NFC:NotifyUserAcceptedP2P":
|
|
this.notifyUserAcceptedP2P(message.data.appId);
|
|
return null;
|
|
case "NFC:NotifySendFileStatus":
|
|
// Upon receiving the status of sendFile operation, send the response
|
|
// to appropriate content process.
|
|
this.notifySendFileStatus(message);
|
|
return null;
|
|
case "NFC:CallDefaultFoundHandler":
|
|
this.callDefaultFoundHandler(message.data);
|
|
return null;
|
|
case "NFC:CallDefaultLostHandler":
|
|
this.callDefaultLostHandler(message.data);
|
|
return null;
|
|
case "NFC:SendFile":
|
|
// Chrome process is the arbitrator / mediator between
|
|
// system app (content process) that issued nfc 'sendFile' operation
|
|
// and system app that handles the system message :
|
|
// 'nfc-manager-send-file'. System app subsequently handover's
|
|
// the data to alternate carrier's (BT / WiFi) 'sendFile' interface.
|
|
|
|
// Notify system app to initiate BT send file operation
|
|
let sysMsg = new NfcSendFileSysMsg(message.data.requestId,
|
|
message.data.sessionToken,
|
|
message.data.blob);
|
|
gSystemMessenger.broadcastMessage("nfc-manager-send-file",
|
|
sysMsg);
|
|
return null;
|
|
default:
|
|
return this.nfc.receiveMessage(message);
|
|
}
|
|
},
|
|
|
|
/**
|
|
* nsIObserver interface methods.
|
|
*/
|
|
|
|
observe: function observe(subject, topic, data) {
|
|
switch (topic) {
|
|
case NFC.TOPIC_MOZSETTINGS_CHANGED:
|
|
if ("wrappedJSObject" in subject) {
|
|
subject = subject.wrappedJSObject;
|
|
}
|
|
if (subject) {
|
|
this.nfc.handle(subject.key, subject.value);
|
|
}
|
|
break;
|
|
case NFC.TOPIC_XPCOM_SHUTDOWN:
|
|
this._shutdown();
|
|
break;
|
|
}
|
|
},
|
|
};
|
|
});
|
|
|
|
var SessionHelper = {
|
|
tokenMap: {},
|
|
|
|
registerSession: function registerSession(id, isP2P) {
|
|
if (this.tokenMap[id]) {
|
|
return this.tokenMap[id].token;
|
|
}
|
|
|
|
this.tokenMap[id] = {
|
|
token: UUIDGenerator.generateUUID().toString(),
|
|
isP2P: isP2P
|
|
};
|
|
|
|
return this.tokenMap[id].token;
|
|
},
|
|
|
|
unregisterSession: function unregisterSession(id) {
|
|
if (this.tokenMap[id]) {
|
|
delete this.tokenMap[id];
|
|
}
|
|
},
|
|
|
|
getToken: function getToken(id) {
|
|
return this.tokenMap[id] ? this.tokenMap[id].token : null;
|
|
},
|
|
|
|
getCurrentP2PToken: function getCurrentP2PToken() {
|
|
for (let id in this.tokenMap) {
|
|
if (this.tokenMap[id] && this.tokenMap[id].isP2P) {
|
|
return this.tokenMap[id].token;
|
|
}
|
|
}
|
|
return null;
|
|
},
|
|
|
|
getId: function getId(token) {
|
|
for (let id in this.tokenMap) {
|
|
if (this.tokenMap[id].token == token) {
|
|
return id;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
},
|
|
|
|
isP2PSession: function isP2PSession(id) {
|
|
return (this.tokenMap[id] != null) && this.tokenMap[id].isP2P;
|
|
}
|
|
};
|
|
|
|
function Nfc() {
|
|
gMessageManager.init(this);
|
|
|
|
this.targetsByRequestId = {};
|
|
}
|
|
|
|
Nfc.prototype = {
|
|
|
|
classID: NFC_CID,
|
|
classInfo: XPCOMUtils.generateCI({classID: NFC_CID,
|
|
classDescription: "Nfc",
|
|
interfaces: [Ci.nsINfcService]}),
|
|
|
|
QueryInterface: XPCOMUtils.generateQI([Ci.nsIObserver, Ci.nsINfcGonkEventListener]),
|
|
|
|
rfState: NFC.NFC_RF_STATE_IDLE,
|
|
|
|
nfcService: null,
|
|
|
|
targetsByRequestId: null,
|
|
|
|
// temporary variables while NFC initialization is pending
|
|
pendingNfcService: null,
|
|
pendingMessageQueue: [],
|
|
|
|
/**
|
|
* Start NFC service
|
|
*/
|
|
startNfcService: function startNfcService() {
|
|
debug("Starting Nfc Service");
|
|
|
|
let nfcService =
|
|
Cc["@mozilla.org/nfc/service;1"].getService(Ci.nsINfcService);
|
|
if (!nfcService) {
|
|
debug("No nfc service component available!");
|
|
return false;
|
|
}
|
|
|
|
nfcService.start(this);
|
|
this.pendingNfcService = nfcService;
|
|
|
|
return true;
|
|
},
|
|
|
|
/**
|
|
* Shutdown NFC service
|
|
*/
|
|
shutdownNfcService : function shutdownNfcService() {
|
|
debug("Shutting down Nfc Service");
|
|
|
|
this.nfcService.shutdown();
|
|
this.nfcService = null;
|
|
},
|
|
|
|
/**
|
|
* Send arbitrary message to Nfc service.
|
|
*
|
|
* @param nfcMessageType
|
|
* A text message type.
|
|
* @param message [optional]
|
|
* An optional message object to send.
|
|
*/
|
|
sendToNfcService: function sendToNfcService(nfcMessageType, message) {
|
|
message = message || {};
|
|
message.type = nfcMessageType;
|
|
this.nfcService.sendCommand(message);
|
|
},
|
|
|
|
sendFileStatusResponse: function sendFileStatusResponse(message) {
|
|
let target = this.getTargetByRequestId(message.requestId);
|
|
if (!target) {
|
|
return;
|
|
}
|
|
|
|
target.sendAsyncMessage("NFC:NotifySendFileStatusResponse", message);
|
|
},
|
|
|
|
sendNfcResponse: function sendNfcResponse(message) {
|
|
let target = this.getTargetByRequestId(message.requestId);
|
|
if (!target) {
|
|
return;
|
|
}
|
|
|
|
target.sendAsyncMessage(EventMsgTable[message.type], message);
|
|
},
|
|
|
|
getTargetByRequestId: function getTargetByRequestId(requestId) {
|
|
let target = this.targetsByRequestId[requestId];
|
|
if (!target) {
|
|
debug("No target for requestId: " + requestId);
|
|
return null;
|
|
}
|
|
delete this.targetsByRequestId[requestId];
|
|
|
|
return target;
|
|
},
|
|
|
|
/**
|
|
* Send Error response to content process.
|
|
*
|
|
* @param message
|
|
* An nsIMessageListener's message parameter.
|
|
* @param errorMsg
|
|
* A string with an error message.
|
|
*/
|
|
sendNfcErrorResponse: function sendNfcErrorResponse(message, errorMsg) {
|
|
if (!message.target) {
|
|
return;
|
|
}
|
|
|
|
let nfcMsgType = message.name + "Response";
|
|
message.data.errorMsg = errorMsg;
|
|
message.target.sendAsyncMessage(nfcMsgType, message.data);
|
|
},
|
|
|
|
getErrorMessage: function getErrorMessage(errorCode) {
|
|
return NFC.NFC_ERROR_MSG[errorCode];
|
|
},
|
|
|
|
/**
|
|
* Process the incoming message from the NFC Service.
|
|
*/
|
|
onEvent: function onEvent(event) {
|
|
let message = Cu.cloneInto(event, this);
|
|
DEBUG && debug("Received message from NFC Service: " + JSON.stringify(message));
|
|
|
|
message.type = message.rspType || message.ntfType;
|
|
switch (message.type) {
|
|
case NfcNotificationType.INITIALIZED:
|
|
this.nfcService = this.pendingNfcService;
|
|
// Send messages that have been queued up during initialization
|
|
// TODO: Bug 1141007: send error responses if the message
|
|
// indicates an error during initialization.
|
|
while (this.pendingMessageQueue.length) {
|
|
this.receiveMessage(this.pendingMessageQueue.shift());
|
|
}
|
|
this.pendingNfcService = null;
|
|
break;
|
|
case NfcNotificationType.TECH_DISCOVERED:
|
|
// Update the upper layers with a session token (alias)
|
|
message.sessionToken =
|
|
SessionHelper.registerSession(message.sessionId, message.isP2P);
|
|
// Do not expose the actual session to the content
|
|
let sessionId = message.sessionId;
|
|
delete message.sessionId;
|
|
|
|
if (SessionHelper.isP2PSession(sessionId)) {
|
|
gMessageManager.onPeerEvent(NFC.PEER_EVENT_FOUND, message.sessionToken);
|
|
} else {
|
|
gMessageManager.onTagFound(message);
|
|
}
|
|
break;
|
|
case NfcNotificationType.TECH_LOST:
|
|
// Update the upper layers with a session token (alias)
|
|
message.sessionToken = SessionHelper.getToken(message.sessionId);
|
|
if (SessionHelper.isP2PSession(message.sessionId)) {
|
|
gMessageManager.onPeerEvent(NFC.PEER_EVENT_LOST, message.sessionToken);
|
|
} else {
|
|
gMessageManager.onTagLost(message.sessionToken);
|
|
}
|
|
|
|
SessionHelper.unregisterSession(message.sessionId);
|
|
break;
|
|
case NfcNotificationType.HCI_EVENT_TRANSACTION:
|
|
this.notifyHCIEventTransaction(message);
|
|
break;
|
|
case NfcNotificationType.NDEF_RECEIVED:
|
|
message.sessionToken = SessionHelper.getToken(message.sessionId);
|
|
delete message.sessionId;
|
|
message.isP2P = true;
|
|
// TODO: Bug 1082493.
|
|
// This event should be sent to the focus app, but before Bug 1082493
|
|
// is landed we forward this to System app.
|
|
gMessageManager.callDefaultFoundHandler(message);
|
|
break;
|
|
case NfcResponseType.CHANGE_RF_STATE_RSP:
|
|
this.sendNfcResponse(message);
|
|
|
|
if (!message.errorMsg) {
|
|
this.rfState = message.rfState;
|
|
gMessageManager.onRFStateChanged(this.rfState);
|
|
}
|
|
if (this.rfState == NFC.NFC_RF_STATE_IDLE) {
|
|
this.shutdownNfcService();
|
|
}
|
|
break;
|
|
case NfcResponseType.READ_NDEF_RSP: // Fall through.
|
|
case NfcResponseType.WRITE_NDEF_RSP:
|
|
case NfcResponseType.MAKE_READ_ONLY_RSP:
|
|
case NfcResponseType.FORMAT_RSP:
|
|
case NfcResponseType.TRANSCEIVE_RSP:
|
|
this.sendNfcResponse(message);
|
|
break;
|
|
default:
|
|
throw new Error("Don't know about this message type: " + message.type);
|
|
}
|
|
},
|
|
|
|
// HCI Event Transaction
|
|
notifyHCIEventTransaction: function notifyHCIEventTransaction(message) {
|
|
delete message.type;
|
|
/**
|
|
* FIXME:
|
|
* GSMA 6.0 7.4 UI Application triggering requirements
|
|
* This specifies the need for the following parameters to be derived and
|
|
* sent. One unclear spec is what the URI format "secure:0" refers to, given
|
|
* SEName can be something like "SIM1" or "SIM2".
|
|
*
|
|
* 1) Mime-type - Secure Element application dependent
|
|
* 2) URI, of the format: nfc://secure:0/<SEName>/<AID>
|
|
* - SEName reflects the originating SE. It must be compliant with
|
|
* SIMAlliance Open Mobile APIs
|
|
* - AID reflects the originating UICC applet identifier
|
|
* 3) Data - Data payload of the transaction notification, if any.
|
|
*/
|
|
gSystemMessenger.broadcastMessage("nfc-hci-event-transaction", message);
|
|
},
|
|
|
|
/**
|
|
* Process a message from the gMessageManager.
|
|
*/
|
|
receiveMessage: function receiveMessage(message) {
|
|
// Return early if we don't need the NFC Service. We won't start
|
|
// the NFC daemon here.
|
|
switch (message.name) {
|
|
case "NFC:QueryInfo":
|
|
return {rfState: this.rfState};
|
|
default:
|
|
break;
|
|
}
|
|
|
|
// Start NFC Service if necessary. Messages are held in a
|
|
// queue while initialization is being performed.
|
|
if (!this.nfcService) {
|
|
if ((message.name == "NFC:ChangeRFState") &&
|
|
(message.data.rfState != "idle") &&
|
|
!this.pendingNfcService) {
|
|
this.startNfcService(); // error handled in next branch
|
|
}
|
|
if (this.pendingNfcService) {
|
|
this.pendingMessageQueue.push(message);
|
|
} else {
|
|
this.sendNfcErrorResponse(message, "NotInitialize");
|
|
}
|
|
return;
|
|
}
|
|
|
|
// NFC Service is running and we have a message for it. This
|
|
// is the case during normal operation.
|
|
if (message.name != "NFC:ChangeRFState") {
|
|
// Update the current sessionId before sending to the NFC service.
|
|
message.data.sessionId = SessionHelper.getId(message.data.sessionToken);
|
|
}
|
|
|
|
let command = CommandMsgTable[message.name];
|
|
if (!command) {
|
|
debug("Unknown message: " + message.name);
|
|
return null;
|
|
}
|
|
this.targetsByRequestId[message.data.requestId] = message.target;
|
|
this.sendToNfcService(command, message.data);
|
|
return null;
|
|
},
|
|
|
|
removeTarget: function removeTarget(target) {
|
|
Object.keys(this.targetsByRequestId).forEach((requestId) => {
|
|
if (this.targetsByRequestId[requestId] === target) {
|
|
delete this.targetsByRequestId[requestId];
|
|
}
|
|
});
|
|
},
|
|
|
|
/**
|
|
* nsISettingsServiceCallback
|
|
*/
|
|
handle: function handle(name, result) {
|
|
switch (name) {
|
|
case NFC.SETTING_NFC_DEBUG:
|
|
DEBUG = result;
|
|
updateDebug();
|
|
break;
|
|
}
|
|
},
|
|
|
|
/**
|
|
* nsIObserver interface methods.
|
|
*/
|
|
observe: function(subject, topic, data) {
|
|
if (topic != "profile-after-change") {
|
|
debug("Should receive 'profile-after-change' only, received " + topic);
|
|
}
|
|
},
|
|
|
|
shutdown: function shutdown() {
|
|
// We shutdown before initialization has been completed. The
|
|
// pending messages will receive an error response.
|
|
while (this.pendingMessageQueue.length) {
|
|
this.sendNfcErrorResponse(this.pendingMessageQueue.shift(), "NotInitialize");
|
|
}
|
|
if (this.nfcService) {
|
|
this.shutdownNfcService();
|
|
}
|
|
}
|
|
};
|
|
|
|
function NfcTechDiscoveredSysMsg(sessionToken, isP2P, records) {
|
|
this.sessionToken = sessionToken;
|
|
this.isP2P = isP2P;
|
|
this.records = records;
|
|
}
|
|
NfcTechDiscoveredSysMsg.prototype = {
|
|
QueryInterface: XPCOMUtils.generateQI([Ci.nsINfcTechDiscoveredSysMsg]),
|
|
|
|
sessionToken: null,
|
|
isP2P: null,
|
|
records: null
|
|
};
|
|
|
|
function NfcSendFileSysMsg(requestId, sessionToken, blob) {
|
|
this.requestId = requestId;
|
|
this.sessionToken = sessionToken;
|
|
this.blob = blob;
|
|
}
|
|
NfcSendFileSysMsg.prototype = {
|
|
QueryInterface: XPCOMUtils.generateQI([Ci.nsINfcSendFileSysMsg]),
|
|
|
|
requestId: null,
|
|
sessionToken: null,
|
|
blob: null
|
|
};
|
|
|
|
if (NFC_ENABLED) {
|
|
this.NSGetFactory = XPCOMUtils.generateNSGetFactory([Nfc]);
|
|
}
|