summaryrefslogtreecommitdiffstats
path: root/dom/system/gonk/ril_worker.js
diff options
context:
space:
mode:
authorMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
committerMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
commit5f8de423f190bbb79a62f804151bc24824fa32d8 (patch)
tree10027f336435511475e392454359edea8e25895d /dom/system/gonk/ril_worker.js
parent49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff)
downloadUXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.lz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.xz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.zip
Add m-esr52 at 52.6.0
Diffstat (limited to 'dom/system/gonk/ril_worker.js')
-rw-r--r--dom/system/gonk/ril_worker.js15206
1 files changed, 15206 insertions, 0 deletions
diff --git a/dom/system/gonk/ril_worker.js b/dom/system/gonk/ril_worker.js
new file mode 100644
index 000000000..0608a5be3
--- /dev/null
+++ b/dom/system/gonk/ril_worker.js
@@ -0,0 +1,15206 @@
+/* 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.
+ */
+
+/**
+ * This file implements the RIL worker thread. It communicates with
+ * the main thread to provide a high-level API to the phone's RIL
+ * stack, and with the RIL IPC thread to communicate with the RIL
+ * device itself. These communication channels use message events as
+ * known from Web Workers:
+ *
+ * - postMessage()/"message" events for main thread communication
+ *
+ * - postRILMessage()/"RILMessageEvent" events for RIL IPC thread
+ * communication.
+ *
+ * The two main objects in this file represent individual parts of this
+ * communication chain:
+ *
+ * - RILMessageEvent -> Buf -> RIL -> postMessage() -> nsIRadioInterfaceLayer
+ * - nsIRadioInterfaceLayer -> postMessage() -> RIL -> Buf -> postRILMessage()
+ *
+ * Note: The code below is purposely lean on abstractions to be as lean in
+ * terms of object allocations. As a result, it may look more like C than
+ * JavaScript, and that's intended.
+ */
+
+/* global BufObject */
+/* global TelephonyRequestQueue */
+
+"use strict";
+
+importScripts("ril_consts.js");
+importScripts("resource://gre/modules/workers/require.js");
+importScripts("ril_worker_buf_object.js");
+importScripts("ril_worker_telephony_request_queue.js");
+
+// set to true in ril_consts.js to see debug messages
+var DEBUG = DEBUG_WORKER;
+var GLOBAL = this;
+
+if (!this.debug) {
+ // Debugging stub that goes nowhere.
+ this.debug = function debug(message) {
+ dump("RIL Worker: " + message + "\n");
+ };
+}
+
+// Timeout value for emergency callback mode.
+const EMERGENCY_CB_MODE_TIMEOUT_MS = 300000; // 5 mins = 300000 ms.
+
+const ICC_MAX_LINEAR_FIXED_RECORDS = 0xfe;
+
+const GET_CURRENT_CALLS_RETRY_MAX = 3;
+
+var RILQUIRKS_CALLSTATE_EXTRA_UINT32;
+var RILQUIRKS_REQUEST_USE_DIAL_EMERGENCY_CALL;
+var RILQUIRKS_SIM_APP_STATE_EXTRA_FIELDS;
+var RILQUIRKS_SIGNAL_EXTRA_INT32;
+var RILQUIRKS_AVAILABLE_NETWORKS_EXTRA_STRING;
+// Needed for call-waiting on Peak device
+var RILQUIRKS_EXTRA_UINT32_2ND_CALL;
+// On the emulator we support querying the number of lock retries
+var RILQUIRKS_HAVE_QUERY_ICC_LOCK_RETRY_COUNT;
+// Ril quirk to Send STK Profile Download
+var RILQUIRKS_SEND_STK_PROFILE_DOWNLOAD;
+// Ril quirk to attach data registration on demand.
+var RILQUIRKS_DATA_REGISTRATION_ON_DEMAND;
+// Ril quirk to control the uicc/data subscription.
+var RILQUIRKS_SUBSCRIPTION_CONTROL;
+// Ril quirk to describe the SMSC address format.
+var RILQUIRKS_SMSC_ADDRESS_FORMAT;
+
+/**
+ * The RIL state machine.
+ *
+ * This object communicates with rild via parcels and with the main thread
+ * via post messages. It maintains state about the radio, ICC, calls, etc.
+ * and acts upon state changes accordingly.
+ */
+function RilObject(aContext) {
+ this.context = aContext;
+
+ this.telephonyRequestQueue = new TelephonyRequestQueue(this);
+ this.currentConferenceState = CALL_STATE_UNKNOWN;
+ this._pendingSentSmsMap = {};
+ this.pendingNetworkType = {};
+ this._receivedSmsCbPagesMap = {};
+ this._getCurrentCallsRetryCount = 0;
+}
+RilObject.prototype = {
+ context: null,
+
+ /**
+ * RIL version.
+ */
+ version: null,
+
+ /**
+ * Call state of current conference group.
+ */
+ currentConferenceState: null,
+
+ /**
+ * Outgoing messages waiting for SMS-STATUS-REPORT.
+ */
+ _pendingSentSmsMap: null,
+
+ /**
+ * Marker object.
+ */
+ pendingNetworkType: null,
+
+ /**
+ * Global Cell Broadcast switch.
+ */
+ cellBroadcastDisabled: false,
+
+ /**
+ * Parsed Cell Broadcast search lists.
+ * cellBroadcastConfigs.MMI should be preserved over rild reset.
+ */
+ cellBroadcastConfigs: null,
+ mergedCellBroadcastConfig: null,
+
+ _receivedSmsCbPagesMap: null,
+
+ initRILState: function() {
+ /**
+ * One of the RADIO_STATE_* constants.
+ */
+ this.radioState = GECKO_RADIOSTATE_UNKNOWN;
+
+ /**
+ * True if we are on a CDMA phone.
+ */
+ this._isCdma = false;
+
+ /**
+ * True if we are in emergency callback mode.
+ */
+ this._isInEmergencyCbMode = false;
+
+ /**
+ * Set when radio is ready but radio tech is unknown. That is, we are
+ * waiting for REQUEST_VOICE_RADIO_TECH
+ */
+ this._waitingRadioTech = false;
+
+ /**
+ * Card state
+ */
+ this.cardState = GECKO_CARDSTATE_UNINITIALIZED;
+
+ /**
+ * Device Identities including IMEI, IMEISV, ESN and MEID.
+ */
+ this.deviceIdentities = null;
+
+ /**
+ * ICC information that is not exposed to Gaia.
+ */
+ this.iccInfoPrivate = {};
+
+ /**
+ * ICC information, such as MSISDN, MCC, MNC, SPN...etc.
+ */
+ this.iccInfo = {};
+
+ /**
+ * CDMA specific information. ex. CDMA Network ID, CDMA System ID... etc.
+ */
+ this.cdmaHome = null;
+
+ /**
+ * Application identification for apps in ICC.
+ */
+ this.aid = null;
+
+ /**
+ * Application type for apps in ICC.
+ */
+ this.appType = null;
+
+ this.networkSelectionMode = GECKO_NETWORK_SELECTION_UNKNOWN;
+
+ this.voiceRegistrationState = {};
+ this.dataRegistrationState = {};
+
+ /**
+ * List of strings identifying the network operator.
+ */
+ this.operator = null;
+
+ /**
+ * String containing the baseband version.
+ */
+ this.basebandVersion = null;
+
+ // Clean up currentCalls: rild might have restarted.
+ this.sendChromeMessage({
+ rilMessageType: "currentCalls",
+ calls: {}
+ });
+
+ // Don't clean up this._pendingSentSmsMap
+ // because on rild restart: we may continue with the pending segments.
+
+ /**
+ * Whether or not the multiple requests in requestNetworkInfo() are currently
+ * being processed
+ */
+ this._processingNetworkInfo = false;
+
+ /**
+ * Multiple requestNetworkInfo() in a row before finishing the first
+ * request, hence we need to fire requestNetworkInfo() again after
+ * gathering all necessary stuffs. This is to make sure that ril_worker
+ * gets precise network information.
+ */
+ this._needRepollNetworkInfo = false;
+
+ /**
+ * Pending messages to be send in batch from requestNetworkInfo()
+ */
+ this._pendingNetworkInfo = {rilMessageType: "networkinfochanged"};
+
+ /**
+ * Cell Broadcast Search Lists.
+ */
+ let cbmmi = this.cellBroadcastConfigs && this.cellBroadcastConfigs.MMI;
+ this.cellBroadcastConfigs = {
+ MMI: cbmmi || null
+ };
+ this.mergedCellBroadcastConfig = null;
+
+ /**
+ * True when the request to report SMS Memory Status is pending.
+ */
+ this.pendingToReportSmsMemoryStatus = false;
+ this.smsStorageAvailable = true;
+ },
+
+ /**
+ * Parse an integer from a string, falling back to a default value
+ * if the the provided value is not a string or does not contain a valid
+ * number.
+ *
+ * @param string
+ * String to be parsed.
+ * @param defaultValue [optional]
+ * Default value to be used.
+ * @param radix [optional]
+ * A number that represents the numeral system to be used. Default 10.
+ */
+ parseInt: function(string, defaultValue, radix) {
+ let number = parseInt(string, radix || 10);
+ if (!isNaN(number)) {
+ return number;
+ }
+ if (defaultValue === undefined) {
+ defaultValue = null;
+ }
+ return defaultValue;
+ },
+
+
+ /**
+ * Outgoing requests to the RIL. These can be triggered from the
+ * main thread via messages that look like this:
+ *
+ * {rilMessageType: "methodName",
+ * extra: "parameters",
+ * go: "here"}
+ *
+ * So if one of the following methods takes arguments, it takes only one,
+ * an object, which then contains all of the parameters as attributes.
+ * The "@param" documentation is to be interpreted accordingly.
+ */
+
+ /**
+ * Retrieve the ICC's status.
+ */
+ getICCStatus: function() {
+ this.context.Buf.simpleRequest(REQUEST_GET_SIM_STATUS);
+ },
+
+ /**
+ * Helper function for unlocking ICC locks.
+ */
+ iccUnlockCardLock: function(options) {
+ switch (options.lockType) {
+ case GECKO_CARDLOCK_PIN:
+ this.enterICCPIN(options);
+ break;
+ case GECKO_CARDLOCK_PIN2:
+ this.enterICCPIN2(options);
+ break;
+ case GECKO_CARDLOCK_PUK:
+ this.enterICCPUK(options);
+ break;
+ case GECKO_CARDLOCK_PUK2:
+ this.enterICCPUK2(options);
+ break;
+ case GECKO_CARDLOCK_NCK:
+ case GECKO_CARDLOCK_NSCK:
+ case GECKO_CARDLOCK_NCK1:
+ case GECKO_CARDLOCK_NCK2:
+ case GECKO_CARDLOCK_HNCK:
+ case GECKO_CARDLOCK_CCK:
+ case GECKO_CARDLOCK_SPCK:
+ case GECKO_CARDLOCK_PCK:
+ case GECKO_CARDLOCK_RCCK:
+ case GECKO_CARDLOCK_RSPCK:
+ case GECKO_CARDLOCK_NCK_PUK:
+ case GECKO_CARDLOCK_NSCK_PUK:
+ case GECKO_CARDLOCK_NCK1_PUK:
+ case GECKO_CARDLOCK_NCK2_PUK:
+ case GECKO_CARDLOCK_HNCK_PUK:
+ case GECKO_CARDLOCK_CCK_PUK:
+ case GECKO_CARDLOCK_SPCK_PUK:
+ case GECKO_CARDLOCK_PCK_PUK:
+ case GECKO_CARDLOCK_RCCK_PUK: // Fall through.
+ case GECKO_CARDLOCK_RSPCK_PUK:
+ this.enterDepersonalization(options);
+ break;
+ default:
+ options.errorMsg = GECKO_ERROR_REQUEST_NOT_SUPPORTED;
+ this.sendChromeMessage(options);
+ }
+ },
+
+ /**
+ * Enter a PIN to unlock the ICC.
+ *
+ * @param password
+ * String containing the PIN.
+ * @param [optional] aid
+ * AID value.
+ */
+ enterICCPIN: function(options) {
+ let Buf = this.context.Buf;
+ Buf.newParcel(REQUEST_ENTER_SIM_PIN, options);
+ Buf.writeInt32(2);
+ Buf.writeString(options.password);
+ Buf.writeString(options.aid || this.aid);
+ Buf.sendParcel();
+ },
+
+ /**
+ * Enter a PIN2 to unlock the ICC.
+ *
+ * @param password
+ * String containing the PIN2.
+ * @param [optional] aid
+ * AID value.
+ */
+ enterICCPIN2: function(options) {
+ let Buf = this.context.Buf;
+ Buf.newParcel(REQUEST_ENTER_SIM_PIN2, options);
+ Buf.writeInt32(2);
+ Buf.writeString(options.password);
+ Buf.writeString(options.aid || this.aid);
+ Buf.sendParcel();
+ },
+
+ /**
+ * Requests a network personalization be deactivated.
+ *
+ * @param personlization
+ * One of CARD_PERSOSUBSTATE_*
+ * @param password
+ * String containing the password.
+ */
+ enterDepersonalization: function(options) {
+ let Buf = this.context.Buf;
+ Buf.newParcel(REQUEST_ENTER_NETWORK_DEPERSONALIZATION_CODE, options);
+ Buf.writeInt32(1);
+ Buf.writeString(options.password);
+ Buf.sendParcel();
+ },
+
+ /**
+ * Change the current ICC PIN number.
+ *
+ * @param password
+ * String containing the old PIN value
+ * @param newPassword
+ * String containing the new PIN value
+ * @param [optional] aid
+ * AID value.
+ */
+ changeICCPIN: function(options) {
+ let Buf = this.context.Buf;
+ Buf.newParcel(REQUEST_CHANGE_SIM_PIN, options);
+ Buf.writeInt32(3);
+ Buf.writeString(options.password);
+ Buf.writeString(options.newPassword);
+ Buf.writeString(options.aid || this.aid);
+ Buf.sendParcel();
+ },
+
+ /**
+ * Change the current ICC PIN2 number.
+ *
+ * @param password
+ * String containing the old PIN2 value
+ * @param newPassword
+ * String containing the new PIN2 value
+ * @param [optional] aid
+ * AID value.
+ */
+ changeICCPIN2: function(options) {
+ let Buf = this.context.Buf;
+ Buf.newParcel(REQUEST_CHANGE_SIM_PIN2, options);
+ Buf.writeInt32(3);
+ Buf.writeString(options.password);
+ Buf.writeString(options.newPassword);
+ Buf.writeString(options.aid || this.aid);
+ Buf.sendParcel();
+ },
+
+ /**
+ * Supplies ICC PUK and a new PIN to unlock the ICC.
+ *
+ * @param password
+ * String containing the PUK value.
+ * @param newPassword
+ * String containing the new PIN value.
+ * @param [optional] aid
+ * AID value.
+ */
+ enterICCPUK: function(options) {
+ let Buf = this.context.Buf;
+ Buf.newParcel(REQUEST_ENTER_SIM_PUK, options);
+ Buf.writeInt32(3);
+ Buf.writeString(options.password);
+ Buf.writeString(options.newPin);
+ Buf.writeString(options.aid || this.aid);
+ Buf.sendParcel();
+ },
+
+ /**
+ * Supplies ICC PUK2 and a new PIN2 to unlock the ICC.
+ *
+ * @param password
+ * String containing the PUK2 value.
+ * @param newPassword
+ * String containing the new PIN2 value.
+ * @param [optional] aid
+ * AID value.
+ */
+ enterICCPUK2: function(options) {
+ let Buf = this.context.Buf;
+ Buf.newParcel(REQUEST_ENTER_SIM_PUK2, options);
+ Buf.writeInt32(3);
+ Buf.writeString(options.password);
+ Buf.writeString(options.newPin);
+ Buf.writeString(options.aid || this.aid);
+ Buf.sendParcel();
+ },
+
+ /**
+ * Helper function for changing ICC locks.
+ */
+ iccChangeCardLockPassword: function(options) {
+ switch (options.lockType) {
+ case GECKO_CARDLOCK_PIN:
+ this.changeICCPIN(options);
+ break;
+ case GECKO_CARDLOCK_PIN2:
+ this.changeICCPIN2(options);
+ break;
+ default:
+ options.errorMsg = GECKO_ERROR_REQUEST_NOT_SUPPORTED;
+ this.sendChromeMessage(options);
+ }
+ },
+
+ /**
+ * Helper function for setting the state of ICC locks.
+ */
+ iccSetCardLockEnabled: function(options) {
+ switch (options.lockType) {
+ case GECKO_CARDLOCK_PIN: // Fall through.
+ case GECKO_CARDLOCK_FDN:
+ options.facility = GECKO_CARDLOCK_TO_FACILITY[options.lockType];
+ break;
+ default:
+ options.errorMsg = GECKO_ERROR_REQUEST_NOT_SUPPORTED;
+ this.sendChromeMessage(options);
+ return;
+ }
+
+ options.serviceClass = ICC_SERVICE_CLASS_VOICE |
+ ICC_SERVICE_CLASS_DATA |
+ ICC_SERVICE_CLASS_FAX;
+ this.setICCFacilityLock(options);
+ },
+
+ /**
+ * Helper function for fetching the state of ICC locks.
+ */
+ iccGetCardLockEnabled: function(options) {
+ switch (options.lockType) {
+ case GECKO_CARDLOCK_PIN: // Fall through.
+ case GECKO_CARDLOCK_FDN:
+ options.facility = GECKO_CARDLOCK_TO_FACILITY[options.lockType];
+ break;
+ default:
+ options.errorMsg = GECKO_ERROR_REQUEST_NOT_SUPPORTED;
+ this.sendChromeMessage(options);
+ return;
+ }
+
+ options.password = ""; // For query no need to provide pin.
+ options.serviceClass = ICC_SERVICE_CLASS_VOICE |
+ ICC_SERVICE_CLASS_DATA |
+ ICC_SERVICE_CLASS_FAX;
+ this.queryICCFacilityLock(options);
+ },
+
+ /**
+ * Helper function for fetching the number of unlock retries of ICC locks.
+ *
+ * We only query the retry count when we're on the emulator. The phones do
+ * not support the request id and their rild doesn't return an error.
+ */
+ iccGetCardLockRetryCount: function(options) {
+ if (!RILQUIRKS_HAVE_QUERY_ICC_LOCK_RETRY_COUNT) {
+ // Only the emulator supports this request.
+ options.errorMsg = GECKO_ERROR_REQUEST_NOT_SUPPORTED;
+ this.sendChromeMessage(options);
+ return;
+ }
+
+ switch (options.lockType) {
+ case GECKO_CARDLOCK_PIN:
+ case GECKO_CARDLOCK_PIN2:
+ case GECKO_CARDLOCK_PUK:
+ case GECKO_CARDLOCK_PUK2:
+ case GECKO_CARDLOCK_NCK:
+ case GECKO_CARDLOCK_NSCK:
+ case GECKO_CARDLOCK_CCK: // Fall through.
+ case GECKO_CARDLOCK_SPCK:
+ // TODO: Bug 1116072: identify the mapping between RIL_PERSOSUBSTATE_SIM_SIM
+ // @ ril.h and TS 27.007, clause 8.65 for GECKO_CARDLOCK_SPCK.
+ options.selCode = GECKO_CARDLOCK_TO_SEL_CODE[options.lockType];
+ break;
+ default:
+ options.errorMsg = GECKO_ERROR_REQUEST_NOT_SUPPORTED;
+ this.sendChromeMessage(options);
+ return;
+ }
+
+ this.queryICCLockRetryCount(options);
+ },
+
+ /**
+ * Query ICC lock retry count.
+ *
+ * @param selCode
+ * One of ICC_SEL_CODE_*.
+ * @param serviceClass
+ * One of ICC_SERVICE_CLASS_*.
+ */
+ queryICCLockRetryCount: function(options) {
+ let Buf = this.context.Buf;
+ Buf.newParcel(REQUEST_GET_UNLOCK_RETRY_COUNT, options);
+ Buf.writeInt32(1);
+ Buf.writeString(options.selCode);
+ Buf.sendParcel();
+ },
+
+ /**
+ * Query ICC facility lock.
+ *
+ * @param facility
+ * One of ICC_CB_FACILITY_*.
+ * @param password
+ * Password for the facility, or "" if not required.
+ * @param serviceClass
+ * One of ICC_SERVICE_CLASS_*.
+ * @param [optional] aid
+ * AID value.
+ */
+ queryICCFacilityLock: function(options) {
+ let Buf = this.context.Buf;
+ Buf.newParcel(REQUEST_QUERY_FACILITY_LOCK, options);
+ Buf.writeInt32(4);
+ Buf.writeString(options.facility);
+ Buf.writeString(options.password);
+ Buf.writeString(options.serviceClass.toString());
+ Buf.writeString(options.aid || this.aid);
+ Buf.sendParcel();
+ },
+
+ /**
+ * Set ICC facility lock.
+ *
+ * @param facility
+ * One of ICC_CB_FACILITY_*.
+ * @param enabled
+ * true to enable, false to disable.
+ * @param password
+ * Password for the facility, or "" if not required.
+ * @param serviceClass
+ * One of ICC_SERVICE_CLASS_*.
+ * @param [optional] aid
+ * AID value.
+ */
+ setICCFacilityLock: function(options) {
+ let Buf = this.context.Buf;
+ Buf.newParcel(REQUEST_SET_FACILITY_LOCK, options);
+ Buf.writeInt32(5);
+ Buf.writeString(options.facility);
+ Buf.writeString(options.enabled ? "1" : "0");
+ Buf.writeString(options.password);
+ Buf.writeString(options.serviceClass.toString());
+ Buf.writeString(options.aid || this.aid);
+ Buf.sendParcel();
+ },
+
+ /**
+ * Request an ICC I/O operation.
+ *
+ * See TS 27.007 "restricted SIM" operation, "AT Command +CRSM".
+ * The sequence is in the same order as how libril reads this parcel,
+ * see the struct RIL_SIM_IO_v5 or RIL_SIM_IO_v6 defined in ril.h
+ *
+ * @param command
+ * The I/O command, one of the ICC_COMMAND_* constants.
+ * @param fileId
+ * The file to operate on, one of the ICC_EF_* constants.
+ * @param pathId
+ * String type, check the 'pathid' parameter from TS 27.007 +CRSM.
+ * @param p1, p2, p3
+ * Arbitrary integer parameters for the command.
+ * @param [optional] dataWriter
+ * The function for writing string parameter for the ICC_COMMAND_UPDATE_RECORD.
+ * @param [optional] pin2
+ * String containing the PIN2.
+ * @param [optional] aid
+ * AID value.
+ */
+ iccIO: function(options) {
+ let Buf = this.context.Buf;
+ Buf.newParcel(REQUEST_SIM_IO, options);
+ Buf.writeInt32(options.command);
+ Buf.writeInt32(options.fileId);
+ Buf.writeString(options.pathId);
+ Buf.writeInt32(options.p1);
+ Buf.writeInt32(options.p2);
+ Buf.writeInt32(options.p3);
+
+ // Write data.
+ if (options.command == ICC_COMMAND_UPDATE_RECORD &&
+ options.dataWriter) {
+ options.dataWriter(options.p3);
+ } else {
+ Buf.writeString(null);
+ }
+
+ // Write pin2.
+ if (options.command == ICC_COMMAND_UPDATE_RECORD &&
+ options.pin2) {
+ Buf.writeString(options.pin2);
+ } else {
+ Buf.writeString(null);
+ }
+
+ Buf.writeString(options.aid || this.aid);
+ Buf.sendParcel();
+ },
+
+ /**
+ * Get IMSI.
+ *
+ * @param [optional] aid
+ * AID value.
+ */
+ getIMSI: function(aid) {
+ let Buf = this.context.Buf;
+ Buf.newParcel(REQUEST_GET_IMSI);
+ Buf.writeInt32(1);
+ Buf.writeString(aid || this.aid);
+ Buf.sendParcel();
+ },
+
+ /**
+ * Retrieve ICC's GID1 field.
+ */
+ getGID1: function(options) {
+ options.gid1 = this.iccInfoPrivate.gid1;
+ this.sendChromeMessage(options);
+ },
+
+ /**
+ * Read UICC Phonebook contacts.
+ *
+ * @param contactType
+ * One of GECKO_CARDCONTACT_TYPE_*.
+ * @param requestId
+ * Request id from RadioInterfaceLayer.
+ */
+ readICCContacts: function(options) {
+ if (!this.appType) {
+ options.errorMsg = CONTACT_ERR_REQUEST_NOT_SUPPORTED;
+ this.sendChromeMessage(options);
+ return;
+ }
+
+ this.context.ICCContactHelper.readICCContacts(
+ this.appType,
+ options.contactType,
+ function onsuccess(contacts) {
+ for (let i = 0; i < contacts.length; i++) {
+ let contact = contacts[i];
+ let pbrIndex = contact.pbrIndex || 0;
+ let recordIndex = pbrIndex * ICC_MAX_LINEAR_FIXED_RECORDS + contact.recordId;
+ contact.contactId = this.iccInfo.iccid + recordIndex;
+ }
+ // Reuse 'options' to get 'requestId' and 'contactType'.
+ options.contacts = contacts;
+ this.sendChromeMessage(options);
+ }.bind(this),
+ function onerror(errorMsg) {
+ options.errorMsg = errorMsg;
+ this.sendChromeMessage(options);
+ }.bind(this));
+ },
+
+ /**
+ * Update UICC Phonebook.
+ *
+ * @param contactType One of GECKO_CARDCONTACT_TYPE_*.
+ * @param contact The contact will be updated.
+ * @param pin2 PIN2 is required for updating FDN.
+ * @param requestId Request id from RadioInterfaceLayer.
+ */
+ updateICCContact: function(options) {
+ let onsuccess = function onsuccess(updatedContact) {
+ let recordIndex =
+ updatedContact.pbrIndex * ICC_MAX_LINEAR_FIXED_RECORDS + updatedContact.recordId;
+ updatedContact.contactId = this.iccInfo.iccid + recordIndex;
+ options.contact = updatedContact;
+ // Reuse 'options' to get 'requestId' and 'contactType'.
+ this.sendChromeMessage(options);
+ }.bind(this);
+
+ let onerror = function onerror(errorMsg) {
+ options.errorMsg = errorMsg;
+ this.sendChromeMessage(options);
+ }.bind(this);
+
+ if (!this.appType || !options.contact) {
+ onerror(CONTACT_ERR_REQUEST_NOT_SUPPORTED );
+ return;
+ }
+
+ let contact = options.contact;
+ let iccid = this.iccInfo.iccid;
+ let isValidRecordId = false;
+ if (typeof contact.contactId === "string" &&
+ contact.contactId.startsWith(iccid)) {
+ let recordIndex = contact.contactId.substring(iccid.length);
+ contact.pbrIndex = Math.floor(recordIndex / ICC_MAX_LINEAR_FIXED_RECORDS);
+ contact.recordId = recordIndex % ICC_MAX_LINEAR_FIXED_RECORDS;
+ isValidRecordId = contact.recordId > 0 && contact.recordId < 0xff;
+ }
+
+ if (DEBUG) {
+ this.context.debug("Update ICC Contact " + JSON.stringify(contact));
+ }
+
+ let ICCContactHelper = this.context.ICCContactHelper;
+ // If contact has 'recordId' property, updates corresponding record.
+ // If not, inserts the contact into a free record.
+ if (isValidRecordId) {
+ ICCContactHelper.updateICCContact(
+ this.appType, options.contactType, contact, options.pin2, onsuccess, onerror);
+ } else {
+ ICCContactHelper.addICCContact(
+ this.appType, options.contactType, contact, options.pin2, onsuccess, onerror);
+ }
+ },
+
+ /**
+ * Check if operator name needs to be overriden by current voiceRegistrationState
+ * , EFOPL and EFPNN. See 3GPP TS 31.102 clause 4.2.58 EFPNN and 4.2.59 EFOPL
+ * for detail.
+ *
+ * @return true if operator name is overridden, false otherwise.
+ */
+ overrideICCNetworkName: function() {
+ if (!this.operator) {
+ return false;
+ }
+
+ // We won't get network name using PNN and OPL if voice registration isn't
+ // ready.
+ if (!this.voiceRegistrationState.cell ||
+ this.voiceRegistrationState.cell.gsmLocationAreaCode == -1) {
+ return false;
+ }
+
+ let ICCUtilsHelper = this.context.ICCUtilsHelper;
+ let networkName = ICCUtilsHelper.getNetworkNameFromICC(
+ this.operator.mcc,
+ this.operator.mnc,
+ this.voiceRegistrationState.cell.gsmLocationAreaCode);
+
+ if (!networkName) {
+ return false;
+ }
+
+ if (DEBUG) {
+ this.context.debug("Operator names will be overriden: " +
+ "longName = " + networkName.fullName + ", " +
+ "shortName = " + networkName.shortName);
+ }
+
+ this.operator.longName = networkName.fullName;
+ this.operator.shortName = networkName.shortName;
+
+ this._sendNetworkInfoMessage(NETWORK_INFO_OPERATOR, this.operator);
+ return true;
+ },
+
+ /**
+ * Request the phone's radio to be enabled or disabled.
+ *
+ * @param enabled
+ * Boolean indicating the desired state.
+ */
+ setRadioEnabled: function(options) {
+ let Buf = this.context.Buf;
+ Buf.newParcel(REQUEST_RADIO_POWER, options);
+ Buf.writeInt32(1);
+ Buf.writeInt32(options.enabled ? 1 : 0);
+ Buf.sendParcel();
+ },
+
+ /**
+ * Query call waiting status.
+ *
+ */
+ queryCallWaiting: function(options) {
+ let Buf = this.context.Buf;
+ Buf.newParcel(REQUEST_QUERY_CALL_WAITING, options);
+ Buf.writeInt32(1);
+ // As per 3GPP TS 24.083, section 1.6 UE doesn't need to send service
+ // class parameter in call waiting interrogation to network.
+ Buf.writeInt32(ICC_SERVICE_CLASS_NONE);
+ Buf.sendParcel();
+ },
+
+ /**
+ * Set call waiting status.
+ *
+ * @param enabled
+ * Boolean indicating the desired waiting status.
+ * @param serviceClass
+ * One of ICC_SERVICE_CLASS_* constants.
+ */
+ setCallWaiting: function(options) {
+ let Buf = this.context.Buf;
+ Buf.newParcel(REQUEST_SET_CALL_WAITING, options);
+ Buf.writeInt32(2);
+ Buf.writeInt32(options.enabled ? 1 : 0);
+ Buf.writeInt32(options.serviceClass);
+ Buf.sendParcel();
+ },
+
+ /**
+ * Queries current CLIP status.
+ */
+ queryCLIP: function(options) {
+ this.context.Buf.simpleRequest(REQUEST_QUERY_CLIP, options);
+ },
+
+ /**
+ * Queries current CLIR status.
+ *
+ */
+ getCLIR: function(options) {
+ this.context.Buf.simpleRequest(REQUEST_GET_CLIR, options);
+ },
+
+ /**
+ * Enables or disables the presentation of the calling line identity (CLI) to
+ * the called party when originating a call.
+ *
+ * @param options.clirMode
+ * One of the CLIR_* constants.
+ */
+ setCLIR: function(options) {
+ let Buf = this.context.Buf;
+ Buf.newParcel(REQUEST_SET_CLIR, options);
+ Buf.writeInt32(1);
+ Buf.writeInt32(options.clirMode);
+ Buf.sendParcel();
+ },
+
+ /**
+ * Set screen state.
+ *
+ * @param on
+ * Boolean indicating whether the screen should be on or off.
+ */
+ setScreenState: function(options) {
+ let Buf = this.context.Buf;
+ Buf.newParcel(REQUEST_SCREEN_STATE);
+ Buf.writeInt32(1);
+ Buf.writeInt32(options.on ? 1 : 0);
+ Buf.sendParcel();
+ },
+
+ getVoiceRegistrationState: function() {
+ this.context.Buf.simpleRequest(REQUEST_VOICE_REGISTRATION_STATE);
+ },
+
+ getVoiceRadioTechnology: function() {
+ this.context.Buf.simpleRequest(REQUEST_VOICE_RADIO_TECH);
+ },
+
+ getDataRegistrationState: function() {
+ this.context.Buf.simpleRequest(REQUEST_DATA_REGISTRATION_STATE);
+ },
+
+ getOperator: function() {
+ this.context.Buf.simpleRequest(REQUEST_OPERATOR);
+ },
+
+ /**
+ * Set the preferred network type.
+ *
+ * @param options An object contains a valid value of
+ * RIL_PREFERRED_NETWORK_TYPE_TO_GECKO as its `type` attribute.
+ */
+ setPreferredNetworkType: function(options) {
+ let networkType = options.type;
+ if (networkType < 0 || networkType >= RIL_PREFERRED_NETWORK_TYPE_TO_GECKO.length) {
+ options.errorMsg = GECKO_ERROR_INVALID_PARAMETER;
+ this.sendChromeMessage(options);
+ return;
+ }
+
+ let Buf = this.context.Buf;
+ Buf.newParcel(REQUEST_SET_PREFERRED_NETWORK_TYPE, options);
+ Buf.writeInt32(1);
+ Buf.writeInt32(networkType);
+ Buf.sendParcel();
+ },
+
+ /**
+ * Get the preferred network type.
+ */
+ getPreferredNetworkType: function(options) {
+ this.context.Buf.simpleRequest(REQUEST_GET_PREFERRED_NETWORK_TYPE, options);
+ },
+
+ /**
+ * Request neighboring cell ids in GSM network.
+ */
+ getNeighboringCellIds: function(options) {
+ this.context.Buf.simpleRequest(REQUEST_GET_NEIGHBORING_CELL_IDS, options);
+ },
+
+ /**
+ * Request all of the current cell information known to the radio.
+ */
+ getCellInfoList: function(options) {
+ this.context.Buf.simpleRequest(REQUEST_GET_CELL_INFO_LIST, options);
+ },
+
+ /**
+ * Request various states about the network.
+ */
+ requestNetworkInfo: function() {
+ if (this._processingNetworkInfo) {
+ if (DEBUG) {
+ this.context.debug("Network info requested, but we're already " +
+ "requesting network info.");
+ }
+ this._needRepollNetworkInfo = true;
+ return;
+ }
+
+ if (DEBUG) this.context.debug("Requesting network info");
+
+ this._processingNetworkInfo = true;
+ this.getVoiceRegistrationState();
+ this.getDataRegistrationState(); //TODO only GSM
+ this.getOperator();
+ this.getNetworkSelectionMode();
+ this.getSignalStrength();
+ },
+
+ /**
+ * Get the available networks
+ */
+ getAvailableNetworks: function(options) {
+ if (DEBUG) this.context.debug("Getting available networks");
+ let Buf = this.context.Buf;
+ Buf.newParcel(REQUEST_QUERY_AVAILABLE_NETWORKS, options);
+ Buf.sendParcel();
+ },
+
+ /**
+ * Request the radio's network selection mode
+ */
+ getNetworkSelectionMode: function() {
+ if (DEBUG) this.context.debug("Getting network selection mode");
+ this.context.Buf.simpleRequest(REQUEST_QUERY_NETWORK_SELECTION_MODE);
+ },
+
+ /**
+ * Tell the radio to automatically choose a voice/data network
+ */
+ selectNetworkAuto: function(options) {
+ if (DEBUG) this.context.debug("Setting automatic network selection");
+ this.context.Buf.simpleRequest(REQUEST_SET_NETWORK_SELECTION_AUTOMATIC, options);
+ },
+
+ /**
+ * Set the roaming preference mode
+ */
+ setRoamingPreference: function(options) {
+ let Buf = this.context.Buf;
+ Buf.newParcel(REQUEST_CDMA_SET_ROAMING_PREFERENCE, options);
+ Buf.writeInt32(1);
+ Buf.writeInt32(options.mode);
+ Buf.sendParcel();
+ },
+
+ /**
+ * Get the roaming preference mode
+ */
+ queryRoamingPreference: function(options) {
+ this.context.Buf.simpleRequest(REQUEST_CDMA_QUERY_ROAMING_PREFERENCE, options);
+ },
+
+ /**
+ * Set the voice privacy mode
+ */
+ setVoicePrivacyMode: function(options) {
+ let Buf = this.context.Buf;
+ Buf.newParcel(REQUEST_CDMA_SET_PREFERRED_VOICE_PRIVACY_MODE, options);
+ Buf.writeInt32(1);
+ Buf.writeInt32(options.enabled ? 1 : 0);
+ Buf.sendParcel();
+ },
+
+ /**
+ * Get the voice privacy mode
+ */
+ queryVoicePrivacyMode: function(options) {
+ this.context.Buf.simpleRequest(REQUEST_CDMA_QUERY_PREFERRED_VOICE_PRIVACY_MODE, options);
+ },
+
+ /**
+ * Open Logical UICC channel (aid) for Secure Element access
+ */
+ iccOpenChannel: function(options) {
+ let Buf = this.context.Buf;
+ Buf.newParcel(REQUEST_SIM_OPEN_CHANNEL, options);
+ Buf.writeString(options.aid);
+ Buf.sendParcel();
+ },
+
+ /**
+ * Exchange APDU data on an open Logical UICC channel
+ */
+ iccExchangeAPDU: function(options) {
+ let Buf = this.context.Buf;
+ Buf.newParcel(REQUEST_SIM_TRANSMIT_APDU_CHANNEL, options);
+ Buf.writeInt32(options.channel);
+ Buf.writeInt32(options.apdu.cla);
+ Buf.writeInt32(options.apdu.command);
+ Buf.writeInt32(options.apdu.p1);
+ Buf.writeInt32(options.apdu.p2);
+ Buf.writeInt32(options.apdu.p3);
+ Buf.writeString(options.apdu.data);
+ Buf.sendParcel();
+ },
+
+ /**
+ * Close Logical UICC channel
+ */
+ iccCloseChannel: function(options) {
+ let Buf = this.context.Buf;
+ Buf.newParcel(REQUEST_SIM_CLOSE_CHANNEL, options);
+ Buf.writeInt32(1);
+ Buf.writeInt32(options.channel);
+ Buf.sendParcel();
+ },
+
+ /**
+ * Get UICC service state
+ */
+ getIccServiceState: function(options) {
+ switch (options.service) {
+ case GECKO_CARDSERVICE_FDN:
+ let ICCUtilsHelper = this.context.ICCUtilsHelper;
+ options.result = ICCUtilsHelper.isICCServiceAvailable("FDN");
+ break;
+ default:
+ options.errorMsg = GECKO_ERROR_REQUEST_NOT_SUPPORTED;
+ break;
+ }
+ this.sendChromeMessage(options);
+ },
+
+ /**
+ * Enable/Disable UICC subscription
+ */
+ setUiccSubscription: function(options) {
+ if (DEBUG) {
+ this.context.debug("setUiccSubscription: " + JSON.stringify(options));
+ }
+
+ let Buf = this.context.Buf;
+ Buf.newParcel(REQUEST_SET_UICC_SUBSCRIPTION, options);
+ Buf.writeInt32(this.context.clientId);
+ Buf.writeInt32(options.appIndex);
+ Buf.writeInt32(this.context.clientId);
+ Buf.writeInt32(options.enabled ? 1 : 0);
+ Buf.sendParcel();
+ },
+
+ /**
+ * Tell the radio to choose a specific voice/data network
+ */
+ selectNetwork: function(options) {
+ if (DEBUG) {
+ this.context.debug("Setting manual network selection: " +
+ options.mcc + ", " + options.mnc);
+ }
+
+ let numeric = (options.mcc && options.mnc) ? options.mcc + options.mnc : null;
+ let Buf = this.context.Buf;
+ Buf.newParcel(REQUEST_SET_NETWORK_SELECTION_MANUAL, options);
+ Buf.writeString(numeric);
+ Buf.sendParcel();
+ },
+
+ /**
+ * Get the signal strength.
+ */
+ getSignalStrength: function() {
+ this.context.Buf.simpleRequest(REQUEST_SIGNAL_STRENGTH);
+ },
+
+ getDeviceIdentity: function() {
+ this.deviceIdentities || this.context.Buf.simpleRequest(REQUEST_DEVICE_IDENTITY);
+ },
+
+ getBasebandVersion: function() {
+ this.context.Buf.simpleRequest(REQUEST_BASEBAND_VERSION);
+ },
+
+ sendExitEmergencyCbModeRequest: function(options) {
+ this.context.Buf.simpleRequest(REQUEST_EXIT_EMERGENCY_CALLBACK_MODE, options);
+ },
+
+ getCdmaSubscription: function() {
+ this.context.Buf.simpleRequest(REQUEST_CDMA_SUBSCRIPTION);
+ },
+
+ exitEmergencyCbMode: function(options) {
+ // The function could be called by an API from RadioInterfaceLayer or by
+ // ril_worker itself. From ril_worker, we won't pass the parameter
+ // 'options'. In this case, it is marked as internal.
+ if (!options) {
+ options = {internal: true};
+ }
+ this._cancelEmergencyCbModeTimeout();
+ this.sendExitEmergencyCbModeRequest(options);
+ },
+
+ /**
+ * Dial a non-emergency number.
+ *
+ * @param isEmergency
+ * Whether the number is an emergency number.
+ * @param number
+ * String containing the number to dial.
+ * @param clirMode
+ * Integer for showing/hidding the caller Id to the called party.
+ * @param uusInfo
+ * Integer doing something XXX TODO
+ */
+ dial: function(options) {
+ if (options.isEmergency) {
+ options.request = RILQUIRKS_REQUEST_USE_DIAL_EMERGENCY_CALL ?
+ REQUEST_DIAL_EMERGENCY_CALL : REQUEST_DIAL;
+
+ } else {
+ options.request = REQUEST_DIAL;
+
+ // Exit emergency callback mode when user dial a non-emergency call.
+ if (this._isInEmergencyCbMode) {
+ this.exitEmergencyCbMode();
+ }
+ }
+
+ this.telephonyRequestQueue.push(options.request, () => {
+ let Buf = this.context.Buf;
+ Buf.newParcel(options.request, options);
+ Buf.writeString(options.number);
+ Buf.writeInt32(options.clirMode || 0);
+ Buf.writeInt32(options.uusInfo || 0);
+ // TODO Why do we need this extra 0? It was put it in to make this
+ // match the format of the binary message.
+ Buf.writeInt32(0);
+ Buf.sendParcel();
+ });
+ },
+
+ /**
+ * CDMA flash.
+ *
+ * @param featureStr (optional)
+ * Dialing number when the command is used for three-way-calling
+ */
+ cdmaFlash: function(options) {
+ let Buf = this.context.Buf;
+ options.request = REQUEST_CDMA_FLASH;
+ Buf.newParcel(options.request, options);
+ Buf.writeString(options.featureStr || "");
+ Buf.sendParcel();
+ },
+
+ /**
+ * Hang up the phone.
+ *
+ * @param callIndex
+ * Call index (1-based) as reported by REQUEST_GET_CURRENT_CALLS.
+ */
+ hangUpCall: function(options) {
+ this.telephonyRequestQueue.push(REQUEST_HANGUP, () => {
+ let Buf = this.context.Buf;
+ Buf.newParcel(REQUEST_HANGUP, options);
+ Buf.writeInt32(1);
+ Buf.writeInt32(options.callIndex);
+ Buf.sendParcel();
+ });
+ },
+
+ hangUpForeground: function(options) {
+ this.telephonyRequestQueue.push(REQUEST_HANGUP_FOREGROUND_RESUME_BACKGROUND, () => {
+ this.context.Buf.simpleRequest(REQUEST_HANGUP_FOREGROUND_RESUME_BACKGROUND,
+ options);
+ });
+ },
+
+ hangUpBackground: function(options) {
+ this.telephonyRequestQueue.push(REQUEST_HANGUP_WAITING_OR_BACKGROUND, () => {
+ this.context.Buf.simpleRequest(REQUEST_HANGUP_WAITING_OR_BACKGROUND,
+ options);
+ });
+ },
+
+ switchActiveCall: function(options) {
+ this.telephonyRequestQueue.push(REQUEST_SWITCH_WAITING_OR_HOLDING_AND_ACTIVE, () => {
+ this.context.Buf.simpleRequest(REQUEST_SWITCH_WAITING_OR_HOLDING_AND_ACTIVE,
+ options);
+ });
+ },
+
+ udub: function(options) {
+ this.telephonyRequestQueue.push(REQUEST_UDUB, () => {
+ this.context.Buf.simpleRequest(REQUEST_UDUB, options);
+ });
+ },
+
+ answerCall: function(options) {
+ this.telephonyRequestQueue.push(REQUEST_ANSWER, () => {
+ this.context.Buf.simpleRequest(REQUEST_ANSWER, options);
+ });
+ },
+
+ conferenceCall: function(options) {
+ this.telephonyRequestQueue.push(REQUEST_CONFERENCE, () => {
+ this.context.Buf.simpleRequest(REQUEST_CONFERENCE, options);
+ });
+ },
+
+ separateCall: function(options) {
+ this.telephonyRequestQueue.push(REQUEST_SEPARATE_CONNECTION, () => {
+ let Buf = this.context.Buf;
+ Buf.newParcel(REQUEST_SEPARATE_CONNECTION, options);
+ Buf.writeInt32(1);
+ Buf.writeInt32(options.callIndex);
+ Buf.sendParcel();
+ });
+ },
+
+ /**
+ * Get current calls.
+ */
+ getCurrentCalls: function(options) {
+ this.telephonyRequestQueue.push(REQUEST_GET_CURRENT_CALLS, () => {
+ this.context.Buf.simpleRequest(REQUEST_GET_CURRENT_CALLS, options);
+ });
+ },
+
+ /**
+ * Mute or unmute the radio.
+ *
+ * @param mute
+ * Boolean to indicate whether to mute or unmute the radio.
+ */
+ setMute: function(options) {
+ let Buf = this.context.Buf;
+ Buf.newParcel(REQUEST_SET_MUTE);
+ Buf.writeInt32(1);
+ Buf.writeInt32(options.muted ? 1 : 0);
+ Buf.sendParcel();
+ },
+
+ /**
+ * Send an SMS.
+ *
+ * The `options` parameter object should contain the following attributes:
+ *
+ * @param number
+ * String containing the recipient number.
+ * @param body
+ * String containing the message text.
+ * @param envelopeId
+ * Numeric value identifying the sms request.
+ */
+ sendSMS: function(options) {
+ options.langIndex = options.langIndex || PDU_NL_IDENTIFIER_DEFAULT;
+ options.langShiftIndex = options.langShiftIndex || PDU_NL_IDENTIFIER_DEFAULT;
+
+ if (!options.segmentSeq) {
+ // Fist segment to send
+ options.segmentSeq = 1;
+ options.body = options.segments[0].body;
+ options.encodedBodyLength = options.segments[0].encodedBodyLength;
+ }
+
+ let Buf = this.context.Buf;
+ if (this._isCdma) {
+ Buf.newParcel(REQUEST_CDMA_SEND_SMS, options);
+ this.context.CdmaPDUHelper.writeMessage(options);
+ } else {
+ Buf.newParcel(REQUEST_SEND_SMS, options);
+ Buf.writeInt32(2);
+ Buf.writeString(options.SMSC);
+ this.context.GsmPDUHelper.writeMessage(options);
+ }
+ Buf.sendParcel();
+ },
+
+ /**
+ * Acknowledge the receipt and handling of an SMS.
+ *
+ * @param success
+ * Boolean indicating whether the message was successfuly handled.
+ * @param cause
+ * SMS_* constant indicating the reason for unsuccessful handling.
+ */
+ acknowledgeGsmSms: function(success, cause) {
+ let Buf = this.context.Buf;
+ Buf.newParcel(REQUEST_SMS_ACKNOWLEDGE);
+ Buf.writeInt32(2);
+ Buf.writeInt32(success ? 1 : 0);
+ Buf.writeInt32(cause);
+ Buf.sendParcel();
+ },
+
+ /**
+ * Acknowledge the receipt and handling of an SMS.
+ *
+ * @param success
+ * Boolean indicating whether the message was successfuly handled.
+ */
+ ackSMS: function(options) {
+ if (options.result == PDU_FCS_RESERVED) {
+ return;
+ }
+ if (this._isCdma) {
+ this.acknowledgeCdmaSms(options.result == PDU_FCS_OK, options.result);
+ } else {
+ this.acknowledgeGsmSms(options.result == PDU_FCS_OK, options.result);
+ }
+ },
+
+ /**
+ * Acknowledge the receipt and handling of a CDMA SMS.
+ *
+ * @param success
+ * Boolean indicating whether the message was successfuly handled.
+ * @param cause
+ * SMS_* constant indicating the reason for unsuccessful handling.
+ */
+ acknowledgeCdmaSms: function(success, cause) {
+ let Buf = this.context.Buf;
+ Buf.newParcel(REQUEST_CDMA_SMS_ACKNOWLEDGE);
+ Buf.writeInt32(success ? 0 : 1);
+ Buf.writeInt32(cause);
+ Buf.sendParcel();
+ },
+
+ /**
+ * Update received MWI into EF_MWIS.
+ */
+ updateMwis: function(options) {
+ if (this.context.ICCUtilsHelper.isICCServiceAvailable("MWIS")) {
+ this.context.SimRecordHelper.updateMWIS(options.mwi);
+ }
+ },
+
+ /**
+ * Report SMS storage status to modem.
+ */
+ _updateSmsMemoryStatus: function() {
+ let Buf = this.context.Buf;
+ Buf.newParcel(REQUEST_REPORT_SMS_MEMORY_STATUS);
+ Buf.writeInt32(1);
+ Buf.writeInt32(this.smsStorageAvailable ? 1 : 0);
+ Buf.sendParcel();
+ },
+
+ reportSmsMemoryStatus: function(options) {
+ this.pendingToReportSmsMemoryStatus = true;
+ this.smsStorageAvailable = options.isAvailable;
+ this._updateSmsMemoryStatus();
+ },
+
+ setCellBroadcastDisabled: function(options) {
+ this.cellBroadcastDisabled = options.disabled;
+
+ // If |this.mergedCellBroadcastConfig| is null, either we haven't finished
+ // reading required SIM files, or no any channel is ever configured. In
+ // the former case, we'll call |this.updateCellBroadcastConfig()| later
+ // with correct configs; in the latter case, we don't bother resetting CB
+ // to disabled again.
+ if (this.mergedCellBroadcastConfig) {
+ this.updateCellBroadcastConfig();
+ }
+ },
+
+ setCellBroadcastSearchList: function(options) {
+ let getSearchListStr = function(aSearchList) {
+ if (typeof aSearchList === "string" || aSearchList instanceof String) {
+ return aSearchList;
+ }
+
+ // TODO: Set search list for CDMA/GSM individually. Bug 990926
+ let prop = this._isCdma ? "cdma" : "gsm";
+
+ return aSearchList && aSearchList[prop];
+ }.bind(this);
+
+ try {
+ let str = getSearchListStr(options.searchList);
+ this.cellBroadcastConfigs.MMI = this._convertCellBroadcastSearchList(str);
+ } catch (e) {
+ if (DEBUG) {
+ this.context.debug("Invalid Cell Broadcast search list: " + e);
+ }
+ options.errorMsg = GECKO_ERROR_UNSPECIFIED_ERROR;
+ }
+
+ this.sendChromeMessage(options);
+ if (options.errorMsg) {
+ return;
+ }
+
+ this._mergeAllCellBroadcastConfigs();
+ },
+
+ updateCellBroadcastConfig: function() {
+ let activate = !this.cellBroadcastDisabled &&
+ (this.mergedCellBroadcastConfig != null) &&
+ (this.mergedCellBroadcastConfig.length > 0);
+ if (activate) {
+ this.setSmsBroadcastConfig(this.mergedCellBroadcastConfig);
+ } else {
+ // It's unnecessary to set config first if we're deactivating.
+ this.setSmsBroadcastActivation(false);
+ }
+ },
+
+ setGsmSmsBroadcastConfig: function(config) {
+ let Buf = this.context.Buf;
+ Buf.newParcel(REQUEST_GSM_SET_BROADCAST_SMS_CONFIG);
+
+ let numConfigs = config ? config.length / 2 : 0;
+ Buf.writeInt32(numConfigs);
+ for (let i = 0; i < config.length;) {
+ // convert [from, to) to [from, to - 1]
+ Buf.writeInt32(config[i++]);
+ Buf.writeInt32(config[i++] - 1);
+ Buf.writeInt32(0x00);
+ Buf.writeInt32(0xFF);
+ Buf.writeInt32(1);
+ }
+
+ Buf.sendParcel();
+ },
+
+ /**
+ * Send CDMA SMS broadcast config.
+ *
+ * @see 3GPP2 C.R1001 Sec. 9.2 and 9.3
+ */
+ setCdmaSmsBroadcastConfig: function(config) {
+ let Buf = this.context.Buf;
+ // |config| is an array of half-closed range: [[from, to), [from, to), ...].
+ // It will be further decomposed, ex: [1, 4) => 1, 2, 3.
+ Buf.newParcel(REQUEST_CDMA_SET_BROADCAST_SMS_CONFIG);
+
+ let numConfigs = 0;
+ for (let i = 0; i < config.length; i += 2) {
+ numConfigs += (config[i+1] - config[i]);
+ }
+
+ Buf.writeInt32(numConfigs);
+ for (let i = 0; i < config.length;) {
+ let begin = config[i++];
+ let end = config[i++];
+
+ for (let j = begin; j < end; ++j) {
+ Buf.writeInt32(j);
+ Buf.writeInt32(0); // Language Indicator: Unknown or unspecified.
+ Buf.writeInt32(1);
+ }
+ }
+
+ Buf.sendParcel();
+ },
+
+ setSmsBroadcastConfig: function(config) {
+ if (this._isCdma) {
+ this.setCdmaSmsBroadcastConfig(config);
+ } else {
+ this.setGsmSmsBroadcastConfig(config);
+ }
+ },
+
+ setSmsBroadcastActivation: function(activate) {
+ let parcelType = this._isCdma ? REQUEST_CDMA_SMS_BROADCAST_ACTIVATION :
+ REQUEST_GSM_SMS_BROADCAST_ACTIVATION;
+ let Buf = this.context.Buf;
+ Buf.newParcel(parcelType);
+ Buf.writeInt32(1);
+ // See hardware/ril/include/telephony/ril.h, 0 - Activate, 1 - Turn off.
+ Buf.writeInt32(activate ? 0 : 1);
+ Buf.sendParcel();
+ },
+
+ /**
+ * Start a DTMF Tone.
+ *
+ * @param dtmfChar
+ * DTMF signal to send, 0-9, *, +
+ */
+ startTone: function(options) {
+ let Buf = this.context.Buf;
+ Buf.newParcel(REQUEST_DTMF_START, options);
+ Buf.writeString(options.dtmfChar);
+ Buf.sendParcel();
+ },
+
+ stopTone: function() {
+ this.context.Buf.simpleRequest(REQUEST_DTMF_STOP);
+ },
+
+ /**
+ * Send a DTMF tone.
+ *
+ * @param dtmfChar
+ * DTMF signal to send, 0-9, *, +
+ */
+ sendTone: function(options) {
+ let Buf = this.context.Buf;
+ Buf.newParcel(REQUEST_DTMF);
+ Buf.writeString(options.dtmfChar);
+ Buf.sendParcel();
+ },
+
+ /**
+ * Get the Short Message Service Center address.
+ */
+ getSmscAddress: function(options) {
+ this.context.Buf.simpleRequest(REQUEST_GET_SMSC_ADDRESS, options);
+ },
+
+ /**
+ * Set the Short Message Service Center address.
+ *
+ * @param smscAddress
+ * Number part of the SMSC address.
+ * @param typeOfNumber
+ * Type of number in integer, as defined in
+ * |Table 10.5.118: Called party BCD number| of 3GPP TS 24.008.
+ * @param numberPlanIdentification
+ * The index of number plan identification value in
+ * CALLED_PARTY_BCD_NPI array.
+ */
+ setSmscAddress: function(options) {
+ let ton = options.typeOfNumber;
+ let npi = CALLED_PARTY_BCD_NPI[options.numberPlanIdentification];
+
+ // If any of the mandatory arguments is not available, return an error
+ // immediately.
+ if (ton === undefined || npi === undefined || !options.smscAddress) {
+ options.errorMsg = GECKO_ERROR_INVALID_PARAMETER;
+ this.sendChromeMessage(options);
+ return;
+ }
+
+ // Remove all illegal characters in the number string for user-input fault
+ // tolerance.
+ let numStart = options.smscAddress[0] === "+" ? 1 : 0;
+ let number = options.smscAddress.substring(0, numStart) +
+ options.smscAddress.substring(numStart)
+ .replace(/[^0-9*#abc]/ig, "");
+
+ // If the filtered number is an empty string, return an error immediately.
+ if (number.length === 0) {
+ options.errorMsg = GECKO_ERROR_INVALID_PARAMETER;
+ this.sendChromeMessage(options);
+ return;
+ }
+
+ // Init parcel.
+ let Buf = this.context.Buf;
+ Buf.newParcel(REQUEST_SET_SMSC_ADDRESS, options);
+
+ // +---+-----------+---------------+
+ // | 1 | TON | NPI |
+ // +---+-----------+---------------+
+ let tosca = (0x1 << 7) + (ton << 4) + npi;
+ if (RILQUIRKS_SMSC_ADDRESS_FORMAT === "pdu") {
+ let pduHelper = this.context.GsmPDUHelper;
+
+ // Remove the preceding '+', and covert the special BCD digits defined in
+ // |Called party BCD number| of 3GPP TS 24.008 to corresponding
+ // hexadecimal values (refer the following table).
+ //
+ // +=========+=======+=====+
+ // | value | digit | hex |
+ // +========================
+ // | 1 0 1 0 | * | 0xA |
+ // | 1 0 1 1 | # | 0xB |
+ // | 1 1 0 0 | a | 0xC |
+ // | 1 1 0 1 | b | 0xD |
+ // | 1 1 1 0 | c | 0xE |
+ // +=========+=======+=====+
+ //
+ // The replace order is reversed intentionally, because if the digits are
+ // replaced in ascending order, "#" will be converted to "b" and then be
+ // converted again to "d", which generates incorrect result.
+ let pureNumber = number.substring(numStart)
+ .replace(/c/ig, "e")
+ .replace(/b/ig, "d")
+ .replace(/a/ig, "c")
+ .replace(/\#/g, "b")
+ .replace(/\*/g, "a");
+
+ // address length and string length
+ let length = Math.ceil(pureNumber.length / 2) + 1; // +1 octet for TOA
+ let strlen = length * 2 + 2; // +2 semi-octets for length octet
+
+ Buf.writeInt32(strlen);
+ pduHelper.writeHexOctet(length);
+ pduHelper.writeHexOctet(tosca);
+ pduHelper.writeSwappedNibbleBCD(pureNumber);
+ Buf.writeStringDelimiter(strlen);
+ } else /* RILQUIRKS_SMSC_ADDRESS_FORMAT === "text" */ {
+ let sca;
+ sca = '"' + number + '"' + ',' + tosca;
+ Buf.writeString(sca);
+ }
+
+ Buf.sendParcel();
+ },
+
+ /**
+ * Setup a data call.
+ *
+ * @param radioTech
+ * Integer to indicate radio technology.
+ * DATACALL_RADIOTECHNOLOGY_CDMA => CDMA.
+ * DATACALL_RADIOTECHNOLOGY_GSM => GSM.
+ * @param apn
+ * String containing the name of the APN to connect to.
+ * @param user
+ * String containing the username for the APN.
+ * @param passwd
+ * String containing the password for the APN.
+ * @param chappap
+ * Integer containing CHAP/PAP auth type.
+ * DATACALL_AUTH_NONE => PAP and CHAP is never performed.
+ * DATACALL_AUTH_PAP => PAP may be performed.
+ * DATACALL_AUTH_CHAP => CHAP may be performed.
+ * DATACALL_AUTH_PAP_OR_CHAP => PAP / CHAP may be performed.
+ * @param pdptype
+ * String containing PDP type to request. ("IP", "IPV6", ...)
+ */
+ setupDataCall: function(options) {
+ // From ./hardware/ril/include/telephony/ril.h:
+ // ((const char **)data)[0] Radio technology to use: 0-CDMA, 1-GSM/UMTS, 2...
+ // for values above 2 this is RIL_RadioTechnology + 2.
+ //
+ // From frameworks/base/telephony/java/com/android/internal/telephony/DataConnection.java:
+ // if the mRilVersion < 6, radio technology must be GSM/UMTS or CDMA.
+ // Otherwise, it must be + 2
+ //
+ // See also bug 901232 and 867873
+ let radioTech = options.radioTech + 2;
+ let Buf = this.context.Buf;
+ let token = Buf.newParcel(REQUEST_SETUP_DATA_CALL, options);
+ Buf.writeInt32(7);
+ Buf.writeString(radioTech.toString());
+ Buf.writeString(DATACALL_PROFILE_DEFAULT.toString());
+ Buf.writeString(options.apn);
+ Buf.writeString(options.user);
+ Buf.writeString(options.passwd);
+ Buf.writeString(options.chappap.toString());
+ Buf.writeString(options.pdptype);
+ Buf.sendParcel();
+ return token;
+ },
+
+ /**
+ * Deactivate a data call.
+ *
+ * @param cid
+ * String containing CID.
+ * @param reason
+ * One of DATACALL_DEACTIVATE_* constants.
+ */
+ deactivateDataCall: function(options) {
+ let Buf = this.context.Buf;
+ Buf.newParcel(REQUEST_DEACTIVATE_DATA_CALL, options);
+ Buf.writeInt32(2);
+ Buf.writeString(options.cid.toString());
+ Buf.writeString(options.reason !== undefined ?
+ options.reason.toString() :
+ DATACALL_DEACTIVATE_NO_REASON.toString());
+ Buf.sendParcel();
+ },
+
+ /**
+ * Get a list of data calls.
+ */
+ getDataCallList: function(options) {
+ this.context.Buf.simpleRequest(REQUEST_DATA_CALL_LIST, options);
+ },
+
+ _attachDataRegistration: false,
+ /**
+ * Manually attach/detach data registration.
+ *
+ * @param attach
+ * Boolean value indicating attach or detach.
+ */
+ setDataRegistration: function(options) {
+ this._attachDataRegistration = options.attach;
+
+ if (RILQUIRKS_DATA_REGISTRATION_ON_DEMAND) {
+ let request = options.attach ? RIL_REQUEST_GPRS_ATTACH :
+ RIL_REQUEST_GPRS_DETACH;
+ this.context.Buf.simpleRequest(request, options);
+ return;
+ } else if (RILQUIRKS_SUBSCRIPTION_CONTROL && options.attach) {
+ this.context.Buf.simpleRequest(REQUEST_SET_DATA_SUBSCRIPTION, options);
+ return;
+ }
+
+ // We don't really send a request to rild, so instantly reply success to
+ // RadioInterfaceLayer.
+ this.sendChromeMessage(options);
+ },
+
+ /**
+ * Get failure casue code for the most recently failed PDP context.
+ */
+ getFailCause: function(options) {
+ this.context.Buf.simpleRequest(REQUEST_LAST_CALL_FAIL_CAUSE, options);
+ },
+
+ /**
+ * Send USSD.
+ *
+ * @param ussd
+ * String containing the USSD code.
+ */
+ sendUSSD: function(options) {
+ let Buf = this.context.Buf;
+ Buf.newParcel(REQUEST_SEND_USSD, options);
+ Buf.writeString(options.ussd);
+ Buf.sendParcel();
+ },
+
+ /**
+ * Cancel pending USSD.
+ */
+ cancelUSSD: function(options) {
+ this.context.Buf.simpleRequest(REQUEST_CANCEL_USSD, options);
+ },
+
+ /**
+ * Queries current call forward rules.
+ *
+ * @param reason
+ * One of CALL_FORWARD_REASON_* constants.
+ * @param serviceClass
+ * One of ICC_SERVICE_CLASS_* constants.
+ * @param number
+ * Phone number of forwarding address.
+ */
+ queryCallForwardStatus: function(options) {
+ let Buf = this.context.Buf;
+ let number = options.number || "";
+ Buf.newParcel(REQUEST_QUERY_CALL_FORWARD_STATUS, options);
+ Buf.writeInt32(CALL_FORWARD_ACTION_QUERY_STATUS);
+ Buf.writeInt32(options.reason);
+ Buf.writeInt32(options.serviceClass || ICC_SERVICE_CLASS_NONE);
+ Buf.writeInt32(this._toaFromString(number));
+ Buf.writeString(number);
+ Buf.writeInt32(0);
+ Buf.sendParcel();
+ },
+
+ /**
+ * Configures call forward rule.
+ *
+ * @param action
+ * One of CALL_FORWARD_ACTION_* constants.
+ * @param reason
+ * One of CALL_FORWARD_REASON_* constants.
+ * @param serviceClass
+ * One of ICC_SERVICE_CLASS_* constants.
+ * @param number
+ * Phone number of forwarding address.
+ * @param timeSeconds
+ * Time in seconds to wait beforec all is forwarded.
+ */
+ setCallForward: function(options) {
+ let Buf = this.context.Buf;
+ Buf.newParcel(REQUEST_SET_CALL_FORWARD, options);
+ Buf.writeInt32(options.action);
+ Buf.writeInt32(options.reason);
+ Buf.writeInt32(options.serviceClass);
+ Buf.writeInt32(this._toaFromString(options.number));
+ Buf.writeString(options.number);
+ Buf.writeInt32(options.timeSeconds);
+ Buf.sendParcel();
+ },
+
+ /**
+ * Queries current call barring rules.
+ *
+ * @param program
+ * One of CALL_BARRING_PROGRAM_* constants.
+ * @param serviceClass
+ * One of ICC_SERVICE_CLASS_* constants.
+ */
+ queryCallBarringStatus: function(options) {
+ options.facility = CALL_BARRING_PROGRAM_TO_FACILITY[options.program];
+ options.password = ""; // For query no need to provide it.
+
+ // For some operators, querying specific serviceClass doesn't work. We use
+ // serviceClass 0 instead, and then process the response to extract the
+ // answer for queryServiceClass.
+ options.queryServiceClass = options.serviceClass;
+ options.serviceClass = 0;
+
+ this.queryICCFacilityLock(options);
+ },
+
+ /**
+ * Configures call barring rule.
+ *
+ * @param program
+ * One of CALL_BARRING_PROGRAM_* constants.
+ * @param enabled
+ * Enable or disable the call barring.
+ * @param password
+ * Barring password.
+ * @param serviceClass
+ * One of ICC_SERVICE_CLASS_* constants.
+ */
+ setCallBarring: function(options) {
+ options.facility = CALL_BARRING_PROGRAM_TO_FACILITY[options.program];
+ this.setICCFacilityLock(options);
+ },
+
+ /**
+ * Change call barring facility password.
+ *
+ * @param pin
+ * Old password.
+ * @param newPin
+ * New password.
+ */
+ changeCallBarringPassword: function(options) {
+ let Buf = this.context.Buf;
+ Buf.newParcel(REQUEST_CHANGE_BARRING_PASSWORD, options);
+ Buf.writeInt32(3);
+ // Set facility to ICC_CB_FACILITY_BA_ALL by following TS.22.030 clause
+ // 6.5.4 and Table B.1.
+ Buf.writeString(ICC_CB_FACILITY_BA_ALL);
+ Buf.writeString(options.pin);
+ Buf.writeString(options.newPin);
+ Buf.sendParcel();
+ },
+
+ /**
+ * Handle STK CALL_SET_UP request.
+ *
+ * @param hasConfirmed
+ * Does use have confirmed the call requested from ICC?
+ */
+ stkHandleCallSetup: function(options) {
+ let Buf = this.context.Buf;
+ Buf.newParcel(REQUEST_STK_HANDLE_CALL_SETUP_REQUESTED_FROM_SIM);
+ Buf.writeInt32(1);
+ Buf.writeInt32(options.hasConfirmed ? 1 : 0);
+ Buf.sendParcel();
+ },
+
+ /**
+ * Send STK Profile Download.
+ *
+ * @param profile Profile supported by ME.
+ */
+ sendStkTerminalProfile: function(profile) {
+ let Buf = this.context.Buf;
+ let GsmPDUHelper = this.context.GsmPDUHelper;
+
+ Buf.newParcel(REQUEST_STK_SET_PROFILE);
+ Buf.writeInt32(profile.length * 2);
+ for (let i = 0; i < profile.length; i++) {
+ GsmPDUHelper.writeHexOctet(profile[i]);
+ }
+ Buf.writeInt32(0);
+ Buf.sendParcel();
+ },
+
+ /**
+ * Send STK terminal response.
+ *
+ * @param command
+ * @param deviceIdentities
+ * @param resultCode
+ * @param [optional] additionalInformation
+ * @param [optional] itemIdentifier
+ * @param [optional] input
+ * @param [optional] isYesNo
+ * @param [optional] hasConfirmed
+ * @param [optional] localInfo
+ * @param [optional] timer
+ */
+ sendStkTerminalResponse: function(response) {
+ if (response.hasConfirmed !== undefined) {
+ this.stkHandleCallSetup(response);
+ return;
+ }
+
+ let Buf = this.context.Buf;
+ let ComprehensionTlvHelper = this.context.ComprehensionTlvHelper;
+ let GsmPDUHelper = this.context.GsmPDUHelper;
+
+ let command = response.command;
+ Buf.newParcel(REQUEST_STK_SEND_TERMINAL_RESPONSE);
+
+ // 1st mark for Parcel size
+ Buf.startCalOutgoingSize(function(size) {
+ // Parcel size is in string length, which costs 2 uint8 per char.
+ Buf.writeInt32(size / 2);
+ });
+
+ // Command Details
+ GsmPDUHelper.writeHexOctet(COMPREHENSIONTLV_TAG_COMMAND_DETAILS |
+ COMPREHENSIONTLV_FLAG_CR);
+ GsmPDUHelper.writeHexOctet(3);
+ if (command) {
+ GsmPDUHelper.writeHexOctet(command.commandNumber);
+ GsmPDUHelper.writeHexOctet(command.typeOfCommand);
+ GsmPDUHelper.writeHexOctet(command.commandQualifier);
+ } else {
+ GsmPDUHelper.writeHexOctet(0x00);
+ GsmPDUHelper.writeHexOctet(0x00);
+ GsmPDUHelper.writeHexOctet(0x00);
+ }
+
+ // Device Identifier
+ // According to TS102.223/TS31.111 section 6.8 Structure of
+ // TERMINAL RESPONSE, "For all SIMPLE-TLV objects with Min=N,
+ // the ME should set the CR(comprehension required) flag to
+ // comprehension not required.(CR=0)"
+ // Since DEVICE_IDENTITIES and DURATION TLVs have Min=N,
+ // the CR flag is not set.
+ GsmPDUHelper.writeHexOctet(COMPREHENSIONTLV_TAG_DEVICE_ID);
+ GsmPDUHelper.writeHexOctet(2);
+ GsmPDUHelper.writeHexOctet(STK_DEVICE_ID_ME);
+ GsmPDUHelper.writeHexOctet(STK_DEVICE_ID_SIM);
+
+ // Result
+ GsmPDUHelper.writeHexOctet(COMPREHENSIONTLV_TAG_RESULT |
+ COMPREHENSIONTLV_FLAG_CR);
+ if ("additionalInformation" in response) {
+ // In |12.12 Result| TS 11.14, the length of additional information is
+ // varied and all possible values are addressed in 12.12.1-11 of TS 11.14
+ // and 8.12.1-13 in TS 31.111.
+ // However,
+ // 1. Only SEND SS requires info with more than 1 octet.
+ // 2. In rild design, SEND SS is expected to be handled by modem and
+ // UNSOLICITED_STK_EVENT_NOTIFY will be sent to application layer to
+ // indicate appropriate messages to users. TR is not required in this
+ // case.
+ // Hence, we simplify the structure of |additionalInformation| to a
+ // numeric value instead of a octet array.
+ GsmPDUHelper.writeHexOctet(2);
+ GsmPDUHelper.writeHexOctet(response.resultCode);
+ GsmPDUHelper.writeHexOctet(response.additionalInformation);
+ } else {
+ GsmPDUHelper.writeHexOctet(1);
+ GsmPDUHelper.writeHexOctet(response.resultCode);
+ }
+
+ // Item Identifier
+ if (response.itemIdentifier != null) {
+ GsmPDUHelper.writeHexOctet(COMPREHENSIONTLV_TAG_ITEM_ID |
+ COMPREHENSIONTLV_FLAG_CR);
+ GsmPDUHelper.writeHexOctet(1);
+ GsmPDUHelper.writeHexOctet(response.itemIdentifier);
+ }
+
+ // No need to process Text data if user requests help information.
+ if (response.resultCode != STK_RESULT_HELP_INFO_REQUIRED) {
+ let text;
+ let coding = command.options.isUCS2 ?
+ STK_TEXT_CODING_UCS2 :
+ (command.options.isPacked ?
+ STK_TEXT_CODING_GSM_7BIT_PACKED :
+ STK_TEXT_CODING_GSM_8BIT);
+ if (response.isYesNo !== undefined) {
+ // Tag: GET_INKEY
+ // When the ME issues a successful TERMINAL RESPONSE for a GET INKEY
+ // ("Yes/No") command with command qualifier set to "Yes/No", it shall
+ // supply the value '01' when the answer is "positive" and the value
+ // '00' when the answer is "negative" in the Text string data object.
+ GsmPDUHelper.writeHexOctet(COMPREHENSIONTLV_TAG_TEXT_STRING |
+ COMPREHENSIONTLV_FLAG_CR);
+ // Length: 2
+ GsmPDUHelper.writeHexOctet(2);
+ // Value: Coding, Yes/No.
+ GsmPDUHelper.writeHexOctet(coding);
+ GsmPDUHelper.writeHexOctet(response.isYesNo ? 0x01 : 0x00);
+ } else {
+ if (response.input !== undefined) {
+ ComprehensionTlvHelper.writeTextStringTlv(response.input, coding);
+ }
+ }
+ }
+
+ // Duration
+ if (response.resultCode === STK_RESULT_NO_RESPONSE_FROM_USER) {
+ // In TS102 223, 6.4.2 GET INKEY, "if the UICC requests a variable timeout,
+ // the terminal shall wait until either the user enters a single character
+ // or the timeout expires. The timer starts when the text is displayed on
+ // the screen and stops when the TERMINAL RESPONSE is sent. The terminal
+ // shall pass the total display text duration (command execution duration)
+ // to the UICC using the TERMINAL RESPONSE. The time unit of the response
+ // is identical to the time unit of the requested variable timeout."
+ let duration = command && command.options && command.options.duration;
+ if (duration) {
+ GsmPDUHelper.writeHexOctet(COMPREHENSIONTLV_TAG_DURATION);
+ GsmPDUHelper.writeHexOctet(2);
+ GsmPDUHelper.writeHexOctet(duration.timeUnit);
+ GsmPDUHelper.writeHexOctet(duration.timeInterval);
+ }
+ }
+
+ // Local Information
+ if (response.localInfo) {
+ let localInfo = response.localInfo;
+
+ // Location Infomation
+ if (localInfo.locationInfo) {
+ ComprehensionTlvHelper.writeLocationInfoTlv(localInfo.locationInfo);
+ }
+
+ // IMEI
+ if (localInfo.imei != null) {
+ let imei = localInfo.imei;
+ if (imei.length == 15) {
+ imei = imei + "0";
+ }
+
+ GsmPDUHelper.writeHexOctet(COMPREHENSIONTLV_TAG_IMEI);
+ GsmPDUHelper.writeHexOctet(8);
+ for (let i = 0; i < imei.length / 2; i++) {
+ GsmPDUHelper.writeHexOctet(parseInt(imei.substr(i * 2, 2), 16));
+ }
+ }
+
+ // Date and Time Zone
+ if (localInfo.date != null) {
+ ComprehensionTlvHelper.writeDateTimeZoneTlv(localInfo.date);
+ }
+
+ // Language
+ if (localInfo.language) {
+ ComprehensionTlvHelper.writeLanguageTlv(localInfo.language);
+ }
+ }
+
+ // Timer
+ if (response.timer) {
+ let timer = response.timer;
+
+ if (timer.timerId) {
+ GsmPDUHelper.writeHexOctet(COMPREHENSIONTLV_TAG_TIMER_IDENTIFIER);
+ GsmPDUHelper.writeHexOctet(1);
+ GsmPDUHelper.writeHexOctet(timer.timerId);
+ }
+
+ if (timer.timerValue) {
+ ComprehensionTlvHelper.writeTimerValueTlv(timer.timerValue, false);
+ }
+ }
+
+ // Calculate and write Parcel size to 1st mark
+ Buf.stopCalOutgoingSize();
+
+ Buf.writeInt32(0);
+ Buf.sendParcel();
+ },
+
+ /**
+ * Send STK Envelope(Menu Selection) command.
+ *
+ * @param itemIdentifier
+ * @param helpRequested
+ */
+ sendStkMenuSelection: function(command) {
+ command.tag = BER_MENU_SELECTION_TAG;
+ command.deviceId = {
+ sourceId :STK_DEVICE_ID_KEYPAD,
+ destinationId: STK_DEVICE_ID_SIM
+ };
+ this.sendICCEnvelopeCommand(command);
+ },
+
+ /**
+ * Send STK Envelope(Timer Expiration) command.
+ *
+ * @param timer
+ */
+ sendStkTimerExpiration: function(command) {
+ command.tag = BER_TIMER_EXPIRATION_TAG;
+ command.deviceId = {
+ sourceId: STK_DEVICE_ID_ME,
+ destinationId: STK_DEVICE_ID_SIM
+ };
+ command.timerId = command.timer.timerId;
+ command.timerValue = command.timer.timerValue;
+ this.sendICCEnvelopeCommand(command);
+ },
+
+ /**
+ * Send STK Envelope(Event Download) command.
+ * @param event
+ */
+ sendStkEventDownload: function(command) {
+ command.tag = BER_EVENT_DOWNLOAD_TAG;
+ command.eventList = command.event.eventType;
+ switch (command.eventList) {
+ case STK_EVENT_TYPE_LOCATION_STATUS:
+ command.deviceId = {
+ sourceId :STK_DEVICE_ID_ME,
+ destinationId: STK_DEVICE_ID_SIM
+ };
+ command.locationStatus = command.event.locationStatus;
+ // Location info should only be provided when locationStatus is normal.
+ if (command.locationStatus == STK_SERVICE_STATE_NORMAL) {
+ command.locationInfo = command.event.locationInfo;
+ }
+ break;
+ case STK_EVENT_TYPE_MT_CALL:
+ command.deviceId = {
+ sourceId: STK_DEVICE_ID_NETWORK,
+ destinationId: STK_DEVICE_ID_SIM
+ };
+ command.transactionId = 0;
+ command.address = command.event.number;
+ break;
+ case STK_EVENT_TYPE_CALL_DISCONNECTED:
+ command.cause = command.event.error;
+ // Fall through.
+ case STK_EVENT_TYPE_CALL_CONNECTED:
+ command.deviceId = {
+ sourceId: (command.event.isIssuedByRemote ?
+ STK_DEVICE_ID_NETWORK : STK_DEVICE_ID_ME),
+ destinationId: STK_DEVICE_ID_SIM
+ };
+ command.transactionId = 0;
+ break;
+ case STK_EVENT_TYPE_USER_ACTIVITY:
+ command.deviceId = {
+ sourceId: STK_DEVICE_ID_ME,
+ destinationId: STK_DEVICE_ID_SIM
+ };
+ break;
+ case STK_EVENT_TYPE_IDLE_SCREEN_AVAILABLE:
+ command.deviceId = {
+ sourceId: STK_DEVICE_ID_DISPLAY,
+ destinationId: STK_DEVICE_ID_SIM
+ };
+ break;
+ case STK_EVENT_TYPE_LANGUAGE_SELECTION:
+ command.deviceId = {
+ sourceId: STK_DEVICE_ID_ME,
+ destinationId: STK_DEVICE_ID_SIM
+ };
+ command.language = command.event.language;
+ break;
+ case STK_EVENT_TYPE_BROWSER_TERMINATION:
+ command.deviceId = {
+ sourceId: STK_DEVICE_ID_ME,
+ destinationId: STK_DEVICE_ID_SIM
+ };
+ command.terminationCause = command.event.terminationCause;
+ break;
+ }
+ this.sendICCEnvelopeCommand(command);
+ },
+
+ /**
+ * Send REQUEST_STK_SEND_ENVELOPE_COMMAND to ICC.
+ *
+ * @param tag
+ * @patam deviceId
+ * @param [optioanl] itemIdentifier
+ * @param [optional] helpRequested
+ * @param [optional] eventList
+ * @param [optional] locationStatus
+ * @param [optional] locationInfo
+ * @param [optional] address
+ * @param [optional] transactionId
+ * @param [optional] cause
+ * @param [optional] timerId
+ * @param [optional] timerValue
+ * @param [optional] terminationCause
+ */
+ sendICCEnvelopeCommand: function(options) {
+ if (DEBUG) {
+ this.context.debug("Stk Envelope " + JSON.stringify(options));
+ }
+
+ let Buf = this.context.Buf;
+ let ComprehensionTlvHelper = this.context.ComprehensionTlvHelper;
+ let GsmPDUHelper = this.context.GsmPDUHelper;
+
+ Buf.newParcel(REQUEST_STK_SEND_ENVELOPE_COMMAND);
+
+ // 1st mark for Parcel size
+ Buf.startCalOutgoingSize(function(size) {
+ // Parcel size is in string length, which costs 2 uint8 per char.
+ Buf.writeInt32(size / 2);
+ });
+
+ // Write a BER-TLV
+ GsmPDUHelper.writeHexOctet(options.tag);
+ // 2nd mark for BER length
+ Buf.startCalOutgoingSize(function(size) {
+ // BER length is in number of hexOctets, which costs 4 uint8 per hexOctet.
+ GsmPDUHelper.writeHexOctet(size / 4);
+ });
+
+ // Event List
+ if (options.eventList != null) {
+ GsmPDUHelper.writeHexOctet(COMPREHENSIONTLV_TAG_EVENT_LIST |
+ COMPREHENSIONTLV_FLAG_CR);
+ GsmPDUHelper.writeHexOctet(1);
+ GsmPDUHelper.writeHexOctet(options.eventList);
+ }
+
+ // Device Identifies
+ GsmPDUHelper.writeHexOctet(COMPREHENSIONTLV_TAG_DEVICE_ID |
+ COMPREHENSIONTLV_FLAG_CR);
+ GsmPDUHelper.writeHexOctet(2);
+ GsmPDUHelper.writeHexOctet(options.deviceId.sourceId);
+ GsmPDUHelper.writeHexOctet(options.deviceId.destinationId);
+
+ // Item Identifier
+ if (options.itemIdentifier != null) {
+ GsmPDUHelper.writeHexOctet(COMPREHENSIONTLV_TAG_ITEM_ID |
+ COMPREHENSIONTLV_FLAG_CR);
+ GsmPDUHelper.writeHexOctet(1);
+ GsmPDUHelper.writeHexOctet(options.itemIdentifier);
+ }
+
+ // Help Request
+ if (options.helpRequested) {
+ GsmPDUHelper.writeHexOctet(COMPREHENSIONTLV_TAG_HELP_REQUEST |
+ COMPREHENSIONTLV_FLAG_CR);
+ GsmPDUHelper.writeHexOctet(0);
+ // Help Request doesn't have value
+ }
+
+ // Location Status
+ if (options.locationStatus != null) {
+ let len = options.locationStatus.length;
+ GsmPDUHelper.writeHexOctet(COMPREHENSIONTLV_TAG_LOCATION_STATUS |
+ COMPREHENSIONTLV_FLAG_CR);
+ GsmPDUHelper.writeHexOctet(1);
+ GsmPDUHelper.writeHexOctet(options.locationStatus);
+ }
+
+ // Location Info
+ if (options.locationInfo) {
+ ComprehensionTlvHelper.writeLocationInfoTlv(options.locationInfo);
+ }
+
+ // Transaction Id
+ if (options.transactionId != null) {
+ GsmPDUHelper.writeHexOctet(COMPREHENSIONTLV_TAG_TRANSACTION_ID |
+ COMPREHENSIONTLV_FLAG_CR);
+ GsmPDUHelper.writeHexOctet(1);
+ GsmPDUHelper.writeHexOctet(options.transactionId);
+ }
+
+ // Address
+ if (options.address) {
+ GsmPDUHelper.writeHexOctet(COMPREHENSIONTLV_TAG_ADDRESS |
+ COMPREHENSIONTLV_FLAG_CR);
+ let addressLength = options.address[0] == '+' ? options.address.length - 1
+ : options.address.length;
+ ComprehensionTlvHelper.writeLength(
+ Math.ceil(addressLength / 2) + 1 // address BCD + TON
+ );
+ this.context.ICCPDUHelper.writeDiallingNumber(options.address);
+ }
+
+ // Cause of disconnection.
+ if (options.cause != null) {
+ ComprehensionTlvHelper.writeCauseTlv(options.cause);
+ }
+
+ // Timer Identifier
+ if (options.timerId != null) {
+ GsmPDUHelper.writeHexOctet(COMPREHENSIONTLV_TAG_TIMER_IDENTIFIER |
+ COMPREHENSIONTLV_FLAG_CR);
+ GsmPDUHelper.writeHexOctet(1);
+ GsmPDUHelper.writeHexOctet(options.timerId);
+ }
+
+ // Timer Value
+ if (options.timerValue != null) {
+ ComprehensionTlvHelper.writeTimerValueTlv(options.timerValue, true);
+ }
+
+ // Language
+ if (options.language) {
+ ComprehensionTlvHelper.writeLanguageTlv(options.language);
+ }
+
+ // Browser Termination
+ if (options.terminationCause != null) {
+ GsmPDUHelper.writeHexOctet(COMPREHENSIONTLV_TAG_BROWSER_TERMINATION_CAUSE |
+ COMPREHENSIONTLV_FLAG_CR);
+ GsmPDUHelper.writeHexOctet(1);
+ GsmPDUHelper.writeHexOctet(options.terminationCause);
+ }
+
+ // Calculate and write BER length to 2nd mark
+ Buf.stopCalOutgoingSize();
+
+ // Calculate and write Parcel size to 1st mark
+ Buf.stopCalOutgoingSize();
+
+ Buf.writeInt32(0);
+ Buf.sendParcel();
+ },
+
+ /**
+ * Report STK Service is running.
+ */
+ reportStkServiceIsRunning: function() {
+ this.context.Buf.simpleRequest(REQUEST_REPORT_STK_SERVICE_IS_RUNNING);
+ },
+
+ /**
+ * Process ICC status.
+ */
+ _processICCStatus: function(iccStatus) {
+ // If |_waitingRadioTech| is true, we should not get app information because
+ // the |_isCdma| flag is not ready yet. Otherwise we may use wrong index to
+ // get app information, especially for the case that icc card has both cdma
+ // and gsm subscription.
+ if (this._waitingRadioTech) {
+ return;
+ }
+
+ // When |iccStatus.cardState| is not CARD_STATE_PRESENT, set cardState to
+ // undetected.
+ if (iccStatus.cardState !== CARD_STATE_PRESENT) {
+ if (this.cardState !== GECKO_CARDSTATE_UNDETECTED) {
+ this.operator = null;
+ // We should send |cardstatechange| before |iccinfochange|, otherwise we
+ // may lost cardstatechange event when icc card becomes undetected.
+ this.cardState = GECKO_CARDSTATE_UNDETECTED;
+ this.sendChromeMessage({rilMessageType: "cardstatechange",
+ cardState: this.cardState});
+
+ this.iccInfo = {iccType: null};
+ this.context.ICCUtilsHelper.handleICCInfoChange();
+ }
+ return;
+ }
+
+ if (RILQUIRKS_SUBSCRIPTION_CONTROL) {
+ // All appIndex is -1 means the subscription is not activated yet.
+ // Note that we don't support "ims" for now, so we don't take it into
+ // account.
+ let neetToActivate = iccStatus.cdmaSubscriptionAppIndex === -1 &&
+ iccStatus.gsmUmtsSubscriptionAppIndex === -1;
+ if (neetToActivate &&
+ // Note: setUiccSubscription works abnormally when RADIO is OFF,
+ // which causes SMS function broken in Flame.
+ // See bug 1008557 for detailed info.
+ this.radioState === GECKO_RADIOSTATE_ENABLED) {
+ for (let i = 0; i < iccStatus.apps.length; i++) {
+ this.setUiccSubscription({appIndex: i, enabled: true});
+ }
+ }
+ }
+
+ let newCardState;
+ let index = this._isCdma ? iccStatus.cdmaSubscriptionAppIndex
+ : iccStatus.gsmUmtsSubscriptionAppIndex;
+ let app = iccStatus.apps[index];
+ if (app) {
+ // fetchICCRecords will need to read aid, so read aid here.
+ this.aid = app.aid;
+ this.appType = app.app_type;
+ this.iccInfo.iccType = GECKO_CARD_TYPE[this.appType];
+
+ switch (app.app_state) {
+ case CARD_APPSTATE_ILLEGAL:
+ newCardState = GECKO_CARDSTATE_ILLEGAL;
+ break;
+ case CARD_APPSTATE_PIN:
+ newCardState = GECKO_CARDSTATE_PIN_REQUIRED;
+ break;
+ case CARD_APPSTATE_PUK:
+ newCardState = GECKO_CARDSTATE_PUK_REQUIRED;
+ break;
+ case CARD_APPSTATE_SUBSCRIPTION_PERSO:
+ newCardState = PERSONSUBSTATE[app.perso_substate];
+ break;
+ case CARD_APPSTATE_READY:
+ newCardState = GECKO_CARDSTATE_READY;
+ break;
+ case CARD_APPSTATE_UNKNOWN:
+ case CARD_APPSTATE_DETECTED:
+ // Fall through.
+ default:
+ newCardState = GECKO_CARDSTATE_UNKNOWN;
+ }
+
+ let pin1State = app.pin1_replaced ? iccStatus.universalPINState :
+ app.pin1;
+ if (pin1State === CARD_PINSTATE_ENABLED_PERM_BLOCKED) {
+ newCardState = GECKO_CARDSTATE_PERMANENT_BLOCKED;
+ }
+ } else {
+ // Having incorrect app information, set card state to unknown.
+ newCardState = GECKO_CARDSTATE_UNKNOWN;
+ }
+
+ let ICCRecordHelper = this.context.ICCRecordHelper;
+ // Try to get iccId only when cardState left GECKO_CARDSTATE_UNDETECTED.
+ if (iccStatus.cardState === CARD_STATE_PRESENT &&
+ (this.cardState === GECKO_CARDSTATE_UNINITIALIZED ||
+ this.cardState === GECKO_CARDSTATE_UNDETECTED)) {
+ ICCRecordHelper.readICCID();
+ }
+
+ if (this.cardState == newCardState) {
+ return;
+ }
+
+ // This was moved down from CARD_APPSTATE_READY
+ this.requestNetworkInfo();
+ if (newCardState == GECKO_CARDSTATE_READY) {
+ // For type SIM, we need to check EF_phase first.
+ // Other types of ICC we can send Terminal_Profile immediately.
+ if (this.appType == CARD_APPTYPE_SIM) {
+ this.context.SimRecordHelper.readSimPhase();
+ } else if (RILQUIRKS_SEND_STK_PROFILE_DOWNLOAD) {
+ this.sendStkTerminalProfile(STK_SUPPORTED_TERMINAL_PROFILE);
+ }
+
+ ICCRecordHelper.fetchICCRecords();
+ }
+
+ this.cardState = newCardState;
+ this.sendChromeMessage({rilMessageType: "cardstatechange",
+ cardState: this.cardState});
+ },
+
+ /**
+ * Helper for processing responses of functions such as enterICC* and changeICC*.
+ */
+ _processEnterAndChangeICCResponses: function(length, options) {
+ options.retryCount = length ? this.context.Buf.readInt32List()[0] : -1;
+ this.sendChromeMessage(options);
+ },
+
+ // We combine all of the NETWORK_INFO_MESSAGE_TYPES into one "networkinfochange"
+ // message to the RadioInterfaceLayer, so we can avoid sending multiple
+ // VoiceInfoChanged events for both operator / voice_data_registration
+ //
+ // State management here is a little tricky. We need to know both:
+ // 1. Whether or not a response was received for each of the
+ // NETWORK_INFO_MESSAGE_TYPES
+ // 2. The outbound message that corresponds with that response -- but this
+ // only happens when internal state changes (i.e. it isn't guaranteed)
+ //
+ // To collect this state, each message response function first calls
+ // _receivedNetworkInfo, to mark the response as received. When the
+ // final response is received, a call to _sendPendingNetworkInfo is placed
+ // on the next tick of the worker thread.
+ //
+ // Since the original call to _receivedNetworkInfo happens at the top
+ // of the response handler, this gives the final handler a chance to
+ // queue up it's "changed" message by calling _sendNetworkInfoMessage if/when
+ // the internal state has actually changed.
+ _sendNetworkInfoMessage: function(type, message) {
+ if (!this._processingNetworkInfo) {
+ // We only combine these messages in the case of the combined request
+ // in requestNetworkInfo()
+ this.sendChromeMessage(message);
+ return;
+ }
+
+ if (DEBUG) {
+ this.context.debug("Queuing " + type + " network info message: " +
+ JSON.stringify(message));
+ }
+ this._pendingNetworkInfo[type] = message;
+ },
+
+ _receivedNetworkInfo: function(type) {
+ if (DEBUG) this.context.debug("Received " + type + " network info.");
+ if (!this._processingNetworkInfo) {
+ return;
+ }
+
+ let pending = this._pendingNetworkInfo;
+
+ // We still need to track states for events that aren't fired.
+ if (!(type in pending)) {
+ pending[type] = this.pendingNetworkType;
+ }
+
+ // Pending network info is ready to be sent when no more messages
+ // are waiting for responses, but the combined payload hasn't been sent.
+ for (let i = 0; i < NETWORK_INFO_MESSAGE_TYPES.length; i++) {
+ let msgType = NETWORK_INFO_MESSAGE_TYPES[i];
+ if (!(msgType in pending)) {
+ if (DEBUG) {
+ this.context.debug("Still missing some more network info, not " +
+ "notifying main thread.");
+ }
+ return;
+ }
+ }
+
+ // Do a pass to clean up the processed messages that didn't create
+ // a response message, so we don't have unused keys in the outbound
+ // networkinfochanged message.
+ for (let key in pending) {
+ if (pending[key] == this.pendingNetworkType) {
+ delete pending[key];
+ }
+ }
+
+ if (DEBUG) {
+ this.context.debug("All pending network info has been received: " +
+ JSON.stringify(pending));
+ }
+
+ // Send the message on the next tick of the worker's loop, so we give the
+ // last message a chance to call _sendNetworkInfoMessage first.
+ setTimeout(this._sendPendingNetworkInfo.bind(this), 0);
+ },
+
+ _sendPendingNetworkInfo: function() {
+ this.sendChromeMessage(this._pendingNetworkInfo);
+
+ this._processingNetworkInfo = false;
+ for (let i = 0; i < NETWORK_INFO_MESSAGE_TYPES.length; i++) {
+ delete this._pendingNetworkInfo[NETWORK_INFO_MESSAGE_TYPES[i]];
+ }
+
+ if (this._needRepollNetworkInfo) {
+ this._needRepollNetworkInfo = false;
+ this.requestNetworkInfo();
+ }
+ },
+
+ /**
+ * Normalize the signal strength in dBm to the signal level from 0 to 100.
+ *
+ * @param signal
+ * The signal strength in dBm to normalize.
+ * @param min
+ * The signal strength in dBm maps to level 0.
+ * @param max
+ * The signal strength in dBm maps to level 100.
+ *
+ * @return level
+ * The signal level from 0 to 100.
+ */
+ _processSignalLevel: function(signal, min, max) {
+ if (signal <= min) {
+ return 0;
+ }
+
+ if (signal >= max) {
+ return 100;
+ }
+
+ return Math.floor((signal - min) * 100 / (max - min));
+ },
+
+ /**
+ * Process LTE signal strength to the signal info object.
+ *
+ * @param signal
+ * The signal object reported from RIL/modem.
+ *
+ * @return The object of signal strength info.
+ * Or null if invalid signal input.
+ *
+ * TODO: Bug 982013: reconsider the format of signal strength APIs for
+ * GSM/CDMA/LTE to expose details, such as rsrp and rsnnr,
+ * individually.
+ */
+ _processLteSignal: function(signal) {
+ let info = {
+ voice: {
+ signalStrength: null,
+ relSignalStrength: null
+ },
+ data: {
+ signalStrength: null,
+ relSignalStrength: null
+ }
+ };
+
+ // Referring to AOSP, use lteRSRP for signalStrength in dBm.
+ let signalStrength = (signal.lteRSRP === undefined || signal.lteRSRP === 0x7FFFFFFF) ?
+ null : signal.lteRSRP;
+ info.voice.signalStrength = info.data.signalStrength = signalStrength;
+
+ // Referring to AOSP, first determine signalLevel based on RSRP and RSSNR,
+ // then on lteSignalStrength if RSRP and RSSNR are invalid.
+ let rsrpLevel = -1;
+ let rssnrLevel = -1;
+ if (signal.lteRSRP !== undefined &&
+ signal.lteRSRP !== 0x7FFFFFFF &&
+ signal.lteRSRP >= 44 &&
+ signal.lteRSRP <= 140) {
+ rsrpLevel = this._processSignalLevel(signal.lteRSRP * -1, -115, -85);
+ }
+
+ if (signal.lteRSSNR !== undefined &&
+ signal.lteRSSNR !== 0x7FFFFFFF &&
+ signal.lteRSSNR >= -200 &&
+ signal.lteRSSNR <= 300) {
+ rssnrLevel = this._processSignalLevel(signal.lteRSSNR, -30, 130);
+ }
+
+ if (rsrpLevel !== -1 && rssnrLevel !== -1) {
+ info.voice.relSignalStrength = info.data.relSignalStrength =
+ Math.min(rsrpLevel, rssnrLevel);
+ return info;
+ }
+
+ let level = Math.max(rsrpLevel, rssnrLevel);
+ if (level !== -1) {
+ info.voice.relSignalStrength = info.data.relSignalStrength = level;
+ return info;
+ }
+
+ // Valid values are 0-63 as defined in TS 27.007 clause 8.69.
+ if (signal.lteSignalStrength !== undefined &&
+ signal.lteSignalStrength >= 0 &&
+ signal.lteSignalStrength <= 63) {
+ level = this._processSignalLevel(signal.lteSignalStrength, 0, 12);
+ info.voice.relSignalStrength = info.data.relSignalStrength = level;
+ return info;
+ }
+
+ return null;
+ },
+
+ _processSignalStrength: function(signal) {
+ let info = {
+ voice: {
+ signalStrength: null,
+ relSignalStrength: null
+ },
+ data: {
+ signalStrength: null,
+ relSignalStrength: null
+ }
+ };
+
+ // During startup, |radioTech| is not yet defined, so we need to
+ // check it separately.
+ if (("radioTech" in this.voiceRegistrationState) &&
+ !this._isGsmTechGroup(this.voiceRegistrationState.radioTech)) {
+ // CDMA RSSI.
+ // Valid values are positive integers. This value is the actual RSSI value
+ // multiplied by -1. Example: If the actual RSSI is -75, then this
+ // response value will be 75.
+ if (signal.cdmaDBM && signal.cdmaDBM > 0) {
+ let signalStrength = -1 * signal.cdmaDBM;
+ info.voice.signalStrength = signalStrength;
+
+ // -105 and -70 are referred to AOSP's implementation. These values are
+ // not constants and can be customized based on different requirement.
+ let signalLevel = this._processSignalLevel(signalStrength, -105, -70);
+ info.voice.relSignalStrength = signalLevel;
+ }
+
+ // EVDO RSSI.
+ // Valid values are positive integers. This value is the actual RSSI value
+ // multiplied by -1. Example: If the actual RSSI is -75, then this
+ // response value will be 75.
+ if (signal.evdoDBM && signal.evdoDBM > 0) {
+ let signalStrength = -1 * signal.evdoDBM;
+ info.data.signalStrength = signalStrength;
+
+ // -105 and -70 are referred to AOSP's implementation. These values are
+ // not constants and can be customized based on different requirement.
+ let signalLevel = this._processSignalLevel(signalStrength, -105, -70);
+ info.data.relSignalStrength = signalLevel;
+ }
+ } else {
+ // Check LTE level first, and check GSM/UMTS level next if LTE one is not
+ // valid.
+ let lteInfo = this._processLteSignal(signal);
+ if (lteInfo) {
+ info = lteInfo;
+ } else {
+ // GSM signal strength.
+ // Valid values are 0-31 as defined in TS 27.007 8.5.
+ // 0 : -113 dBm or less
+ // 1 : -111 dBm
+ // 2...30: -109...-53 dBm
+ // 31 : -51 dBm
+ if (signal.gsmSignalStrength &&
+ signal.gsmSignalStrength >= 0 &&
+ signal.gsmSignalStrength <= 31) {
+ let signalStrength = -113 + 2 * signal.gsmSignalStrength;
+ info.voice.signalStrength = info.data.signalStrength = signalStrength;
+
+ // -115 and -85 are referred to AOSP's implementation. These values are
+ // not constants and can be customized based on different requirement.
+ let signalLevel = this._processSignalLevel(signalStrength, -110, -85);
+ info.voice.relSignalStrength = info.data.relSignalStrength = signalLevel;
+ }
+ }
+ }
+
+ info.rilMessageType = "signalstrengthchange";
+ this._sendNetworkInfoMessage(NETWORK_INFO_SIGNAL, info);
+ },
+
+ /**
+ * Process the network registration flags.
+ *
+ * @return true if the state changed, false otherwise.
+ */
+ _processCREG: function(curState, newState) {
+ let changed = false;
+
+ let regState = this.parseInt(newState[0], NETWORK_CREG_STATE_UNKNOWN);
+ if (curState.regState === undefined || curState.regState !== regState) {
+ changed = true;
+ curState.regState = regState;
+
+ curState.state = NETWORK_CREG_TO_GECKO_MOBILE_CONNECTION_STATE[regState];
+ curState.connected = regState == NETWORK_CREG_STATE_REGISTERED_HOME ||
+ regState == NETWORK_CREG_STATE_REGISTERED_ROAMING;
+ curState.roaming = regState == NETWORK_CREG_STATE_REGISTERED_ROAMING;
+ curState.emergencyCallsOnly = !curState.connected;
+ }
+
+ if (!curState.cell) {
+ curState.cell = {};
+ }
+
+ // From TS 23.003, 0000 and 0xfffe are indicated that no valid LAI exists
+ // in MS. So we still need to report the '0000' as well.
+ let lac = this.parseInt(newState[1], -1, 16);
+ if (curState.cell.gsmLocationAreaCode === undefined ||
+ curState.cell.gsmLocationAreaCode !== lac) {
+ curState.cell.gsmLocationAreaCode = lac;
+ changed = true;
+ }
+
+ let cid = this.parseInt(newState[2], -1, 16);
+ if (curState.cell.gsmCellId === undefined ||
+ curState.cell.gsmCellId !== cid) {
+ curState.cell.gsmCellId = cid;
+ changed = true;
+ }
+
+ let radioTech = (newState[3] === undefined ?
+ NETWORK_CREG_TECH_UNKNOWN :
+ this.parseInt(newState[3], NETWORK_CREG_TECH_UNKNOWN));
+ if (curState.radioTech === undefined || curState.radioTech !== radioTech) {
+ changed = true;
+ curState.radioTech = radioTech;
+ curState.type = GECKO_RADIO_TECH[radioTech] || null;
+ }
+ return changed;
+ },
+
+ _processVoiceRegistrationState: function(state) {
+ let rs = this.voiceRegistrationState;
+ let stateChanged = this._processCREG(rs, state);
+ if (stateChanged && rs.connected) {
+ this.getSmscAddress();
+ }
+
+ let cell = rs.cell;
+ if (this._isCdma) {
+ // Some variables below are not used. Comment them instead of removing to
+ // keep the information about state[x].
+ let cdmaBaseStationId = this.parseInt(state[4], -1);
+ let cdmaBaseStationLatitude = this.parseInt(state[5], -2147483648);
+ let cdmaBaseStationLongitude = this.parseInt(state[6], -2147483648);
+ // let cssIndicator = this.parseInt(state[7]);
+ let cdmaSystemId = this.parseInt(state[8], -1);
+ let cdmaNetworkId = this.parseInt(state[9], -1);
+ // let roamingIndicator = this.parseInt(state[10]);
+ // let systemIsInPRL = this.parseInt(state[11]);
+ // let defaultRoamingIndicator = this.parseInt(state[12]);
+ // let reasonForDenial = this.parseInt(state[13]);
+
+ if (cell.cdmaBaseStationId !== cdmaBaseStationId ||
+ cell.cdmaBaseStationLatitude !== cdmaBaseStationLatitude ||
+ cell.cdmaBaseStationLongitude !== cdmaBaseStationLongitude ||
+ cell.cdmaSystemId !== cdmaSystemId ||
+ cell.cdmaNetworkId !== cdmaNetworkId) {
+ stateChanged = true;
+ cell.cdmaBaseStationId = cdmaBaseStationId;
+ cell.cdmaBaseStationLatitude = cdmaBaseStationLatitude;
+ cell.cdmaBaseStationLongitude = cdmaBaseStationLongitude;
+ cell.cdmaSystemId = cdmaSystemId;
+ cell.cdmaNetworkId = cdmaNetworkId;
+ }
+ }
+
+ if (stateChanged) {
+ rs.rilMessageType = "voiceregistrationstatechange";
+ this._sendNetworkInfoMessage(NETWORK_INFO_VOICE_REGISTRATION_STATE, rs);
+ }
+ },
+
+ _processDataRegistrationState: function(state) {
+ let rs = this.dataRegistrationState;
+ let stateChanged = this._processCREG(rs, state);
+ if (stateChanged) {
+ rs.rilMessageType = "dataregistrationstatechange";
+ this._sendNetworkInfoMessage(NETWORK_INFO_DATA_REGISTRATION_STATE, rs);
+ }
+ },
+
+ _processOperator: function(operatorData) {
+ if (operatorData.length < 3) {
+ if (DEBUG) {
+ this.context.debug("Expected at least 3 strings for operator.");
+ }
+ }
+
+ if (!this.operator) {
+ this.operator = {
+ rilMessageType: "operatorchange",
+ longName: null,
+ shortName: null
+ };
+ }
+
+ let [longName, shortName, networkTuple] = operatorData;
+ let thisTuple = (this.operator.mcc || "") + (this.operator.mnc || "");
+
+ if (this.operator.longName !== longName ||
+ this.operator.shortName !== shortName ||
+ thisTuple !== networkTuple) {
+
+ this.operator.mcc = null;
+ this.operator.mnc = null;
+
+ if (networkTuple) {
+ try {
+ this._processNetworkTuple(networkTuple, this.operator);
+ } catch (e) {
+ if (DEBUG) this.context.debug("Error processing operator tuple: " + e);
+ }
+ } else {
+ // According to ril.h, the operator fields will be NULL when the operator
+ // is not currently registered. We can avoid trying to parse the numeric
+ // tuple in that case.
+ if (DEBUG) {
+ this.context.debug("Operator is currently unregistered");
+ }
+ }
+
+ this.operator.longName = longName;
+ this.operator.shortName = shortName;
+
+ let ICCUtilsHelper = this.context.ICCUtilsHelper;
+ if (ICCUtilsHelper.updateDisplayCondition()) {
+ ICCUtilsHelper.handleICCInfoChange();
+ }
+
+ // NETWORK_INFO_OPERATOR message will be sent out by overrideICCNetworkName
+ // itself if operator name is overridden after checking, or we have to
+ // do it by ourself.
+ if (!this.overrideICCNetworkName()) {
+ this._sendNetworkInfoMessage(NETWORK_INFO_OPERATOR, this.operator);
+ }
+ }
+ },
+
+ _processSuppSvcNotification: function(info) {
+ if (DEBUG) {
+ this.context.debug("handle supp svc notification: " + JSON.stringify(info));
+ }
+
+ if (info.notificationType !== 1) {
+ // We haven't supported MO intermediate result code, i.e.
+ // info.notificationType === 0, which refers to code1 defined in 3GPP
+ // 27.007 7.17. We only support partial MT unsolicited result code,
+ // referring to code2, for now.
+ return;
+ }
+
+ let notification = null;
+
+ switch (info.code) {
+ case SUPP_SVC_NOTIFICATION_CODE2_PUT_ON_HOLD:
+ case SUPP_SVC_NOTIFICATION_CODE2_RETRIEVED:
+ notification = GECKO_SUPP_SVC_NOTIFICATION_FROM_CODE2[info.code];
+ break;
+ default:
+ // Notification type not supported.
+ return;
+ }
+
+ let message = {rilMessageType: "suppSvcNotification",
+ number: info.number, // could be empty.
+ notification: notification};
+ this.sendChromeMessage(message);
+ },
+
+ _cancelEmergencyCbModeTimeout: function() {
+ if (this._exitEmergencyCbModeTimeoutID) {
+ clearTimeout(this._exitEmergencyCbModeTimeoutID);
+ this._exitEmergencyCbModeTimeoutID = null;
+ }
+ },
+
+ _handleChangedEmergencyCbMode: function(active) {
+ this._isInEmergencyCbMode = active;
+
+ // Clear the existed timeout event.
+ this._cancelEmergencyCbModeTimeout();
+
+ // Start a new timeout event when entering the mode.
+ if (active) {
+ this._exitEmergencyCbModeTimeoutID = setTimeout(
+ this.exitEmergencyCbMode.bind(this), EMERGENCY_CB_MODE_TIMEOUT_MS);
+ }
+
+ let message = {rilMessageType: "emergencyCbModeChange",
+ active: active,
+ timeoutMs: EMERGENCY_CB_MODE_TIMEOUT_MS};
+ this.sendChromeMessage(message);
+ },
+
+ _updateNetworkSelectionMode: function(mode) {
+ if (this.networkSelectionMode === mode) {
+ return;
+ }
+
+ let options = {
+ rilMessageType: "networkselectionmodechange",
+ mode: mode
+ };
+ this.networkSelectionMode = mode;
+ this._sendNetworkInfoMessage(NETWORK_INFO_NETWORK_SELECTION_MODE, options);
+ },
+
+ _processNetworks: function() {
+ let strings = this.context.Buf.readStringList();
+ let networks = [];
+
+ for (let i = 0; i < strings.length;
+ i += RILQUIRKS_AVAILABLE_NETWORKS_EXTRA_STRING ? 5 : 4) {
+ let network = {
+ longName: strings[i],
+ shortName: strings[i + 1],
+ mcc: null,
+ mnc: null,
+ state: null
+ };
+
+ let networkTuple = strings[i + 2];
+ try {
+ this._processNetworkTuple(networkTuple, network);
+ } catch (e) {
+ if (DEBUG) this.context.debug("Error processing operator tuple: " + e);
+ }
+
+ let state = strings[i + 3];
+ network.state = RIL_QAN_STATE_TO_GECKO_STATE[state];
+
+ networks.push(network);
+ }
+ return networks;
+ },
+
+ /**
+ * The "numeric" portion of the operator info is a tuple
+ * containing MCC (country code) and MNC (network code).
+ * AFAICT, MCC should always be 3 digits, making the remaining
+ * portion the MNC.
+ */
+ _processNetworkTuple: function(networkTuple, network) {
+ let tupleLen = networkTuple.length;
+
+ if (tupleLen == 5 || tupleLen == 6) {
+ network.mcc = networkTuple.substr(0, 3);
+ network.mnc = networkTuple.substr(3);
+ } else {
+ network.mcc = null;
+ network.mnc = null;
+
+ throw new Error("Invalid network tuple (should be 5 or 6 digits): " + networkTuple);
+ }
+ },
+
+ /**
+ * Check if GSM radio access technology group.
+ */
+ _isGsmTechGroup: function(radioTech) {
+ if (!radioTech) {
+ return true;
+ }
+
+ switch(radioTech) {
+ case NETWORK_CREG_TECH_GPRS:
+ case NETWORK_CREG_TECH_EDGE:
+ case NETWORK_CREG_TECH_UMTS:
+ case NETWORK_CREG_TECH_HSDPA:
+ case NETWORK_CREG_TECH_HSUPA:
+ case NETWORK_CREG_TECH_HSPA:
+ case NETWORK_CREG_TECH_LTE:
+ case NETWORK_CREG_TECH_HSPAP:
+ case NETWORK_CREG_TECH_GSM:
+ case NETWORK_CREG_TECH_DCHSPAP_1:
+ case NETWORK_CREG_TECH_DCHSPAP_2:
+ return true;
+ }
+
+ return false;
+ },
+
+ /**
+ * Process radio technology change.
+ */
+ _processRadioTech: function(radioTech) {
+ let isCdma = !this._isGsmTechGroup(radioTech);
+ this.radioTech = radioTech;
+
+ if (DEBUG) {
+ this.context.debug("Radio tech is set to: " + GECKO_RADIO_TECH[radioTech] +
+ ", it is a " + (isCdma?"cdma":"gsm") + " technology");
+ }
+
+ // We should request SIM information when
+ // 1. Radio state has been changed, so we are waiting for radioTech or
+ // 2. isCdma is different from this._isCdma.
+ if (this._waitingRadioTech || isCdma != this._isCdma) {
+ this._isCdma = isCdma;
+ this._waitingRadioTech = false;
+ this.getICCStatus();
+ }
+ },
+
+ /**
+ * Helper for returning the TOA for the given dial string.
+ */
+ _toaFromString: function(number) {
+ let toa = TOA_UNKNOWN;
+ if (number && number.length > 0 && number[0] == '+') {
+ toa = TOA_INTERNATIONAL;
+ }
+ return toa;
+ },
+
+ /**
+ * @param message A decoded SMS-DELIVER message.
+ *
+ * @see 3GPP TS 31.111 section 7.1.1
+ */
+ dataDownloadViaSMSPP: function(message) {
+ let Buf = this.context.Buf;
+ let GsmPDUHelper = this.context.GsmPDUHelper;
+
+ let options = {
+ pid: message.pid,
+ dcs: message.dcs,
+ encoding: message.encoding,
+ };
+ Buf.newParcel(REQUEST_STK_SEND_ENVELOPE_WITH_STATUS, options);
+
+ Buf.seekIncoming(-1 * (Buf.getCurrentParcelSize() - Buf.getReadAvailable()
+ - 2 * Buf.UINT32_SIZE)); // Skip response_type & request_type.
+ let messageStringLength = Buf.readInt32(); // In semi-octets
+ let smscLength = GsmPDUHelper.readHexOctet(); // In octets, inclusive of TOA
+ let tpduLength = (messageStringLength / 2) - (smscLength + 1); // In octets
+
+ // Device identities: 4 bytes
+ // Address: 0 or (2 + smscLength)
+ // SMS TPDU: (2 or 3) + tpduLength
+ let berLen = 4 +
+ (smscLength ? (2 + smscLength) : 0) +
+ (tpduLength <= 127 ? 2 : 3) + tpduLength; // In octets
+
+ let parcelLength = (berLen <= 127 ? 2 : 3) + berLen; // In octets
+ Buf.writeInt32(parcelLength * 2); // In semi-octets
+
+ // Write a BER-TLV
+ GsmPDUHelper.writeHexOctet(BER_SMS_PP_DOWNLOAD_TAG);
+ if (berLen > 127) {
+ GsmPDUHelper.writeHexOctet(0x81);
+ }
+ GsmPDUHelper.writeHexOctet(berLen);
+
+ // Device Identifies-TLV
+ GsmPDUHelper.writeHexOctet(COMPREHENSIONTLV_TAG_DEVICE_ID |
+ COMPREHENSIONTLV_FLAG_CR);
+ GsmPDUHelper.writeHexOctet(0x02);
+ GsmPDUHelper.writeHexOctet(STK_DEVICE_ID_NETWORK);
+ GsmPDUHelper.writeHexOctet(STK_DEVICE_ID_SIM);
+
+ // Address-TLV
+ if (smscLength) {
+ GsmPDUHelper.writeHexOctet(COMPREHENSIONTLV_TAG_ADDRESS);
+ GsmPDUHelper.writeHexOctet(smscLength);
+ Buf.copyIncomingToOutgoing(Buf.PDU_HEX_OCTET_SIZE * smscLength);
+ }
+
+ // SMS TPDU-TLV
+ GsmPDUHelper.writeHexOctet(COMPREHENSIONTLV_TAG_SMS_TPDU |
+ COMPREHENSIONTLV_FLAG_CR);
+ if (tpduLength > 127) {
+ GsmPDUHelper.writeHexOctet(0x81);
+ }
+ GsmPDUHelper.writeHexOctet(tpduLength);
+ Buf.copyIncomingToOutgoing(Buf.PDU_HEX_OCTET_SIZE * tpduLength);
+
+ // Write 2 string delimitors for the total string length must be even.
+ Buf.writeStringDelimiter(0);
+
+ Buf.sendParcel();
+ },
+
+ /**
+ * @param success A boolean value indicating the result of previous
+ * SMS-DELIVER message handling.
+ * @param responsePduLen ICC IO response PDU length in octets.
+ * @param options An object that contains four attributes: `pid`, `dcs`,
+ * `encoding` and `responsePduLen`.
+ *
+ * @see 3GPP TS 23.040 section 9.2.2.1a
+ */
+ acknowledgeIncomingGsmSmsWithPDU: function(success, responsePduLen, options) {
+ let Buf = this.context.Buf;
+ let GsmPDUHelper = this.context.GsmPDUHelper;
+
+ Buf.newParcel(REQUEST_ACKNOWLEDGE_INCOMING_GSM_SMS_WITH_PDU);
+
+ // Two strings.
+ Buf.writeInt32(2);
+
+ // String 1: Success
+ Buf.writeString(success ? "1" : "0");
+
+ // String 2: RP-ACK/RP-ERROR PDU
+ Buf.writeInt32(2 * (responsePduLen + (success ? 5 : 6))); // In semi-octet
+ // 1. TP-MTI & TP-UDHI
+ GsmPDUHelper.writeHexOctet(PDU_MTI_SMS_DELIVER);
+ if (!success) {
+ // 2. TP-FCS
+ GsmPDUHelper.writeHexOctet(PDU_FCS_USIM_DATA_DOWNLOAD_ERROR);
+ }
+ // 3. TP-PI
+ GsmPDUHelper.writeHexOctet(PDU_PI_USER_DATA_LENGTH |
+ PDU_PI_DATA_CODING_SCHEME |
+ PDU_PI_PROTOCOL_IDENTIFIER);
+ // 4. TP-PID
+ GsmPDUHelper.writeHexOctet(options.pid);
+ // 5. TP-DCS
+ GsmPDUHelper.writeHexOctet(options.dcs);
+ // 6. TP-UDL
+ if (options.encoding == PDU_DCS_MSG_CODING_7BITS_ALPHABET) {
+ GsmPDUHelper.writeHexOctet(Math.floor(responsePduLen * 8 / 7));
+ } else {
+ GsmPDUHelper.writeHexOctet(responsePduLen);
+ }
+ // TP-UD
+ Buf.copyIncomingToOutgoing(Buf.PDU_HEX_OCTET_SIZE * responsePduLen);
+ // Write 2 string delimitors for the total string length must be even.
+ Buf.writeStringDelimiter(0);
+
+ Buf.sendParcel();
+ },
+
+ /**
+ * @param message A decoded SMS-DELIVER message.
+ */
+ writeSmsToSIM: function(message) {
+ let Buf = this.context.Buf;
+ let GsmPDUHelper = this.context.GsmPDUHelper;
+
+ Buf.newParcel(REQUEST_WRITE_SMS_TO_SIM);
+
+ // Write EFsms Status
+ Buf.writeInt32(EFSMS_STATUS_FREE);
+
+ Buf.seekIncoming(-1 * (Buf.getCurrentParcelSize() - Buf.getReadAvailable()
+ - 2 * Buf.UINT32_SIZE)); // Skip response_type & request_type.
+ let messageStringLength = Buf.readInt32(); // In semi-octets
+ let smscLength = GsmPDUHelper.readHexOctet(); // In octets, inclusive of TOA
+ let pduLength = (messageStringLength / 2) - (smscLength + 1); // In octets
+
+ // 1. Write PDU first.
+ if (smscLength > 0) {
+ Buf.seekIncoming(smscLength * Buf.PDU_HEX_OCTET_SIZE);
+ }
+ // Write EFsms PDU string length
+ Buf.writeInt32(2 * pduLength); // In semi-octets
+ if (pduLength) {
+ Buf.copyIncomingToOutgoing(Buf.PDU_HEX_OCTET_SIZE * pduLength);
+ }
+ // Write 2 string delimitors for the total string length must be even.
+ Buf.writeStringDelimiter(0);
+
+ // 2. Write SMSC
+ // Write EFsms SMSC string length
+ Buf.writeInt32(2 * (smscLength + 1)); // Plus smscLength itself, in semi-octets
+ // Write smscLength
+ GsmPDUHelper.writeHexOctet(smscLength);
+ // Write TOA & SMSC Address
+ if (smscLength) {
+ Buf.seekIncoming(-1 * (Buf.getCurrentParcelSize() - Buf.getReadAvailable()
+ - 2 * Buf.UINT32_SIZE // Skip response_type, request_type.
+ - 2 * Buf.PDU_HEX_OCTET_SIZE)); // Skip messageStringLength & smscLength.
+ Buf.copyIncomingToOutgoing(Buf.PDU_HEX_OCTET_SIZE * smscLength);
+ }
+ // Write 2 string delimitors for the total string length must be even.
+ Buf.writeStringDelimiter(0);
+
+ Buf.sendParcel();
+ },
+
+ /**
+ * Helper to delegate the received sms segment to RadioInterface to process.
+ *
+ * @param message
+ * Received sms message.
+ *
+ * @return MOZ_FCS_WAIT_FOR_EXPLICIT_ACK
+ */
+ _processSmsMultipart: function(message) {
+ message.rilMessageType = "sms-received";
+
+ this.sendChromeMessage(message);
+
+ return MOZ_FCS_WAIT_FOR_EXPLICIT_ACK;
+ },
+
+ /**
+ * Helper for processing SMS-STATUS-REPORT PDUs.
+ *
+ * @param length
+ * Length of SMS string in the incoming parcel.
+ *
+ * @return A failure cause defined in 3GPP 23.040 clause 9.2.3.22.
+ */
+ _processSmsStatusReport: function(length) {
+ let [message, result] = this.context.GsmPDUHelper.processReceivedSms(length);
+ if (!message) {
+ if (DEBUG) this.context.debug("invalid SMS-STATUS-REPORT");
+ return PDU_FCS_UNSPECIFIED;
+ }
+
+ let options = this._pendingSentSmsMap[message.messageRef];
+ if (!options) {
+ if (DEBUG) this.context.debug("no pending SMS-SUBMIT message");
+ return PDU_FCS_OK;
+ }
+
+ let status = message.status;
+
+ // 3GPP TS 23.040 9.2.3.15 `The MS shall interpret any reserved values as
+ // "Service Rejected"(01100011) but shall store them exactly as received.`
+ if ((status >= 0x80)
+ || ((status >= PDU_ST_0_RESERVED_BEGIN)
+ && (status < PDU_ST_0_SC_SPECIFIC_BEGIN))
+ || ((status >= PDU_ST_1_RESERVED_BEGIN)
+ && (status < PDU_ST_1_SC_SPECIFIC_BEGIN))
+ || ((status >= PDU_ST_2_RESERVED_BEGIN)
+ && (status < PDU_ST_2_SC_SPECIFIC_BEGIN))
+ || ((status >= PDU_ST_3_RESERVED_BEGIN)
+ && (status < PDU_ST_3_SC_SPECIFIC_BEGIN))
+ ) {
+ status = PDU_ST_3_SERVICE_REJECTED;
+ }
+
+ // Pending. Waiting for next status report.
+ if ((status >>> 5) == 0x01) {
+ if (DEBUG) this.context.debug("SMS-STATUS-REPORT: delivery still pending");
+ return PDU_FCS_OK;
+ }
+
+ delete this._pendingSentSmsMap[message.messageRef];
+
+ let deliveryStatus = ((status >>> 5) === 0x00)
+ ? GECKO_SMS_DELIVERY_STATUS_SUCCESS
+ : GECKO_SMS_DELIVERY_STATUS_ERROR;
+ this.sendChromeMessage({
+ rilMessageType: options.rilMessageType,
+ rilMessageToken: options.rilMessageToken,
+ deliveryStatus: deliveryStatus
+ });
+
+ return PDU_FCS_OK;
+ },
+
+ /**
+ * Helper for processing CDMA SMS Delivery Acknowledgment Message
+ *
+ * @param message
+ * decoded SMS Delivery ACK message from CdmaPDUHelper.
+ *
+ * @return A failure cause defined in 3GPP 23.040 clause 9.2.3.22.
+ */
+ _processCdmaSmsStatusReport: function(message) {
+ let options = this._pendingSentSmsMap[message.msgId];
+ if (!options) {
+ if (DEBUG) this.context.debug("no pending SMS-SUBMIT message");
+ return PDU_FCS_OK;
+ }
+
+ if (message.errorClass === 2) {
+ if (DEBUG) {
+ this.context.debug("SMS-STATUS-REPORT: delivery still pending, " +
+ "msgStatus: " + message.msgStatus);
+ }
+ return PDU_FCS_OK;
+ }
+
+ delete this._pendingSentSmsMap[message.msgId];
+
+ if (message.errorClass === -1 && message.body) {
+ // Process as normal incoming SMS, if errorClass is invalid
+ // but message body is available.
+ return this._processSmsMultipart(message);
+ }
+
+ let deliveryStatus = (message.errorClass === 0)
+ ? GECKO_SMS_DELIVERY_STATUS_SUCCESS
+ : GECKO_SMS_DELIVERY_STATUS_ERROR;
+ this.sendChromeMessage({
+ rilMessageType: options.rilMessageType,
+ rilMessageToken: options.rilMessageToken,
+ deliveryStatus: deliveryStatus
+ });
+
+ return PDU_FCS_OK;
+ },
+
+ /**
+ * Helper for processing CDMA SMS WAP Push Message
+ *
+ * @param message
+ * decoded WAP message from CdmaPDUHelper.
+ *
+ * @return A failure cause defined in 3GPP 23.040 clause 9.2.3.22.
+ */
+ _processCdmaSmsWapPush: function(message) {
+ if (!message.data) {
+ if (DEBUG) this.context.debug("no data inside WAP Push message.");
+ return PDU_FCS_OK;
+ }
+
+ // See 6.5. MAPPING OF WDP TO CDMA SMS in WAP-295-WDP.
+ //
+ // Field | Length (bits)
+ // -----------------------------------------
+ // MSG_TYPE | 8
+ // TOTAL_SEGMENTS | 8
+ // SEGMENT_NUMBER | 8
+ // DATAGRAM | (NUM_FIELDS - 3) * 8
+ let index = 0;
+ if (message.data[index++] !== 0) {
+ if (DEBUG) this.context.debug("Ignore a WAP Message which is not WDP.");
+ return PDU_FCS_OK;
+ }
+
+ // 1. Originator Address in SMS-TL + Message_Id in SMS-TS are used to identify a unique WDP datagram.
+ // 2. TOTAL_SEGMENTS, SEGMENT_NUMBER are used to verify that a complete
+ // datagram has been received and is ready to be passed to a higher layer.
+ message.header = {
+ segmentRef: message.msgId,
+ segmentMaxSeq: message.data[index++],
+ segmentSeq: message.data[index++] + 1 // It's zero-based in CDMA WAP Push.
+ };
+
+ if (message.header.segmentSeq > message.header.segmentMaxSeq) {
+ if (DEBUG) this.context.debug("Wrong WDP segment info.");
+ return PDU_FCS_OK;
+ }
+
+ // Ports are only specified in 1st segment.
+ if (message.header.segmentSeq == 1) {
+ message.header.originatorPort = message.data[index++] << 8;
+ message.header.originatorPort |= message.data[index++];
+ message.header.destinationPort = message.data[index++] << 8;
+ message.header.destinationPort |= message.data[index++];
+ }
+
+ message.data = message.data.subarray(index);
+
+ return this._processSmsMultipart(message);
+ },
+
+ /**
+ * Helper for processing sent multipart SMS.
+ */
+ _processSentSmsSegment: function(options) {
+ // Setup attributes for sending next segment
+ let next = options.segmentSeq;
+ options.body = options.segments[next].body;
+ options.encodedBodyLength = options.segments[next].encodedBodyLength;
+ options.segmentSeq = next + 1;
+
+ this.sendSMS(options);
+ },
+
+ /**
+ * Helper for processing result of send SMS.
+ *
+ * @param length
+ * Length of SMS string in the incoming parcel.
+ * @param options
+ * Sms information.
+ */
+ _processSmsSendResult: function(length, options) {
+ if (options.errorMsg) {
+ if (DEBUG) {
+ this.context.debug("_processSmsSendResult: errorMsg = " +
+ options.errorMsg);
+ }
+
+ this.sendChromeMessage({
+ rilMessageType: options.rilMessageType,
+ rilMessageToken: options.rilMessageToken,
+ errorMsg: options.errorMsg,
+ });
+ return;
+ }
+
+ let Buf = this.context.Buf;
+ options.messageRef = Buf.readInt32();
+ options.ackPDU = Buf.readString();
+ options.errorCode = Buf.readInt32();
+
+ if ((options.segmentMaxSeq > 1)
+ && (options.segmentSeq < options.segmentMaxSeq)) {
+ // Not last segment
+ this._processSentSmsSegment(options);
+ } else {
+ // Last segment sent with success.
+ if (options.requestStatusReport) {
+ if (DEBUG) {
+ this.context.debug("waiting SMS-STATUS-REPORT for messageRef " +
+ options.messageRef);
+ }
+ this._pendingSentSmsMap[options.messageRef] = options;
+ }
+
+ this.sendChromeMessage({
+ rilMessageType: options.rilMessageType,
+ rilMessageToken: options.rilMessageToken,
+ });
+ }
+ },
+
+ _processReceivedSmsCbPage: function(original) {
+ if (original.numPages <= 1) {
+ if (original.body) {
+ original.fullBody = original.body;
+ delete original.body;
+ } else if (original.data) {
+ original.fullData = original.data;
+ delete original.data;
+ }
+ return original;
+ }
+
+ // Hash = <serial>:<mcc>:<mnc>:<lac>:<cid>
+ let hash = original.serial + ":" + this.iccInfo.mcc + ":"
+ + this.iccInfo.mnc + ":";
+ switch (original.geographicalScope) {
+ case CB_GSM_GEOGRAPHICAL_SCOPE_CELL_WIDE_IMMEDIATE:
+ case CB_GSM_GEOGRAPHICAL_SCOPE_CELL_WIDE:
+ hash += this.voiceRegistrationState.cell.gsmLocationAreaCode + ":"
+ + this.voiceRegistrationState.cell.gsmCellId;
+ break;
+ case CB_GSM_GEOGRAPHICAL_SCOPE_LOCATION_AREA_WIDE:
+ hash += this.voiceRegistrationState.cell.gsmLocationAreaCode + ":";
+ break;
+ default:
+ hash += ":";
+ break;
+ }
+
+ let index = original.pageIndex;
+
+ let options = this._receivedSmsCbPagesMap[hash];
+ if (!options) {
+ options = original;
+ this._receivedSmsCbPagesMap[hash] = options;
+
+ options.receivedPages = 0;
+ options.pages = [];
+ } else if (options.pages[index]) {
+ // Duplicated page?
+ if (DEBUG) {
+ this.context.debug("Got duplicated page no." + index +
+ " of a multipage SMSCB: " + JSON.stringify(original));
+ }
+ return null;
+ }
+
+ if (options.encoding == PDU_DCS_MSG_CODING_8BITS_ALPHABET) {
+ options.pages[index] = original.data;
+ delete original.data;
+ } else {
+ options.pages[index] = original.body;
+ delete original.body;
+ }
+ options.receivedPages++;
+ if (options.receivedPages < options.numPages) {
+ if (DEBUG) {
+ this.context.debug("Got page no." + index + " of a multipage SMSCB: " +
+ JSON.stringify(options));
+ }
+ return null;
+ }
+
+ // Remove from map
+ delete this._receivedSmsCbPagesMap[hash];
+
+ // Rebuild full body
+ if (options.encoding == PDU_DCS_MSG_CODING_8BITS_ALPHABET) {
+ // Uint8Array doesn't have `concat`, so we have to merge all pages by hand.
+ let fullDataLen = 0;
+ for (let i = 1; i <= options.numPages; i++) {
+ fullDataLen += options.pages[i].length;
+ }
+
+ options.fullData = new Uint8Array(fullDataLen);
+ for (let d= 0, i = 1; i <= options.numPages; i++) {
+ let data = options.pages[i];
+ for (let j = 0; j < data.length; j++) {
+ options.fullData[d++] = data[j];
+ }
+ }
+ } else {
+ options.fullBody = options.pages.join("");
+ }
+
+ if (DEBUG) {
+ this.context.debug("Got full multipage SMSCB: " + JSON.stringify(options));
+ }
+
+ return options;
+ },
+
+ _mergeCellBroadcastConfigs: function(list, from, to) {
+ if (!list) {
+ return [from, to];
+ }
+
+ for (let i = 0, f1, t1; i < list.length;) {
+ f1 = list[i++];
+ t1 = list[i++];
+ if (to == f1) {
+ // ...[from]...[to|f1]...(t1)
+ list[i - 2] = from;
+ return list;
+ }
+
+ if (to < f1) {
+ // ...[from]...(to)...[f1] or ...[from]...(to)[f1]
+ if (i > 2) {
+ // Not the first range pair, merge three arrays.
+ return list.slice(0, i - 2).concat([from, to]).concat(list.slice(i - 2));
+ } else {
+ return [from, to].concat(list);
+ }
+ }
+
+ if (from > t1) {
+ // ...[f1]...(t1)[from] or ...[f1]...(t1)...[from]
+ continue;
+ }
+
+ // Have overlap or merge-able adjacency with [f1]...(t1). Replace it
+ // with [min(from, f1)]...(max(to, t1)).
+
+ let changed = false;
+ if (from < f1) {
+ // [from]...[f1]...(t1) or [from][f1]...(t1)
+ // Save minimum from value.
+ list[i - 2] = from;
+ changed = true;
+ }
+
+ if (to <= t1) {
+ // [from]...[to](t1) or [from]...(to|t1)
+ // Can't have further merge-able adjacency. Return.
+ return list;
+ }
+
+ // Try merging possible next adjacent range.
+ let j = i;
+ for (let f2, t2; j < list.length;) {
+ f2 = list[j++];
+ t2 = list[j++];
+ if (to > t2) {
+ // [from]...[f2]...[t2]...(to) or [from]...[f2]...[t2](to)
+ // Merge next adjacent range again.
+ continue;
+ }
+
+ if (to < t2) {
+ if (to < f2) {
+ // [from]...(to)[f2] or [from]...(to)...[f2]
+ // Roll back and give up.
+ j -= 2;
+ } else if (to < t2) {
+ // [from]...[to|f2]...(t2), or [from]...[f2]...[to](t2)
+ // Merge to [from]...(t2) and give up.
+ to = t2;
+ }
+ }
+
+ break;
+ }
+
+ // Save maximum to value.
+ list[i - 1] = to;
+
+ if (j != i) {
+ // Remove merged adjacent ranges.
+ let ret = list.slice(0, i);
+ if (j < list.length) {
+ ret = ret.concat(list.slice(j));
+ }
+ return ret;
+ }
+
+ return list;
+ }
+
+ // Append to the end.
+ list.push(from);
+ list.push(to);
+
+ return list;
+ },
+
+ _isCellBroadcastConfigReady: function() {
+ if (!("MMI" in this.cellBroadcastConfigs)) {
+ return false;
+ }
+
+ // CBMI should be ready in GSM.
+ if (!this._isCdma &&
+ (!("CBMI" in this.cellBroadcastConfigs) ||
+ !("CBMID" in this.cellBroadcastConfigs) ||
+ !("CBMIR" in this.cellBroadcastConfigs))) {
+ return false;
+ }
+
+ return true;
+ },
+
+ /**
+ * Merge all members of cellBroadcastConfigs into mergedCellBroadcastConfig.
+ */
+ _mergeAllCellBroadcastConfigs: function() {
+ if (!this._isCellBroadcastConfigReady()) {
+ if (DEBUG) {
+ this.context.debug("cell broadcast configs not ready, waiting ...");
+ }
+ return;
+ }
+
+ // Prepare cell broadcast config. CBMI* are only used in GSM.
+ let usedCellBroadcastConfigs = {MMI: this.cellBroadcastConfigs.MMI};
+ if (!this._isCdma) {
+ usedCellBroadcastConfigs.CBMI = this.cellBroadcastConfigs.CBMI;
+ usedCellBroadcastConfigs.CBMID = this.cellBroadcastConfigs.CBMID;
+ usedCellBroadcastConfigs.CBMIR = this.cellBroadcastConfigs.CBMIR;
+ }
+
+ if (DEBUG) {
+ this.context.debug("Cell Broadcast search lists: " +
+ JSON.stringify(usedCellBroadcastConfigs));
+ }
+
+ let list = null;
+ for (let key in usedCellBroadcastConfigs) {
+ let ll = usedCellBroadcastConfigs[key];
+ if (ll == null) {
+ continue;
+ }
+
+ for (let i = 0; i < ll.length; i += 2) {
+ list = this._mergeCellBroadcastConfigs(list, ll[i], ll[i + 1]);
+ }
+ }
+
+ if (DEBUG) {
+ this.context.debug("Cell Broadcast search lists(merged): " +
+ JSON.stringify(list));
+ }
+ this.mergedCellBroadcastConfig = list;
+ this.updateCellBroadcastConfig();
+ },
+
+ /**
+ * Check whether search list from settings is settable by MMI, that is,
+ * whether the range is bounded in any entries of CB_NON_MMI_SETTABLE_RANGES.
+ */
+ _checkCellBroadcastMMISettable: function(from, to) {
+ if ((to <= from) || (from >= 65536) || (from < 0)) {
+ return false;
+ }
+
+ if (!this._isCdma) {
+ // GSM not settable ranges.
+ for (let i = 0, f, t; i < CB_NON_MMI_SETTABLE_RANGES.length;) {
+ f = CB_NON_MMI_SETTABLE_RANGES[i++];
+ t = CB_NON_MMI_SETTABLE_RANGES[i++];
+ if ((from < t) && (to > f)) {
+ // Have overlap.
+ return false;
+ }
+ }
+ }
+
+ return true;
+ },
+
+ /**
+ * Convert Cell Broadcast settings string into search list.
+ */
+ _convertCellBroadcastSearchList: function(searchListStr) {
+ let parts = searchListStr && searchListStr.split(",");
+ if (!parts) {
+ return null;
+ }
+
+ let list = null;
+ let result, from, to;
+ for (let range of parts) {
+ // Match "12" or "12-34". The result will be ["12", "12", null] or
+ // ["12-34", "12", "34"].
+ result = range.match(/^(\d+)(?:-(\d+))?$/);
+ if (!result) {
+ throw "Invalid format";
+ }
+
+ from = parseInt(result[1], 10);
+ to = (result[2]) ? parseInt(result[2], 10) + 1 : from + 1;
+ if (!this._checkCellBroadcastMMISettable(from, to)) {
+ throw "Invalid range";
+ }
+
+ if (list == null) {
+ list = [];
+ }
+ list.push(from);
+ list.push(to);
+ }
+
+ return list;
+ },
+
+ /**
+ * Handle incoming messages from the main UI thread.
+ *
+ * @param message
+ * Object containing the message. Messages are supposed
+ */
+ handleChromeMessage: function(message) {
+ if (DEBUG) {
+ this.context.debug("Received chrome message " + JSON.stringify(message));
+ }
+ let method = this[message.rilMessageType];
+ if (typeof method != "function") {
+ if (DEBUG) {
+ this.context.debug("Don't know what to do with message " +
+ JSON.stringify(message));
+ }
+ return;
+ }
+ method.call(this, message);
+ },
+
+ /**
+ * Process STK Proactive Command.
+ */
+ processStkProactiveCommand: function() {
+ let Buf = this.context.Buf;
+ let length = Buf.readInt32();
+ let berTlv;
+ try {
+ berTlv = this.context.BerTlvHelper.decode(length / 2);
+ } catch (e) {
+ if (DEBUG) this.context.debug("processStkProactiveCommand : " + e);
+ this.sendStkTerminalResponse({
+ resultCode: STK_RESULT_CMD_DATA_NOT_UNDERSTOOD});
+ return;
+ }
+
+ Buf.readStringDelimiter(length);
+
+ let ctlvs = berTlv.value;
+ let ctlv = this.context.StkProactiveCmdHelper.searchForTag(
+ COMPREHENSIONTLV_TAG_COMMAND_DETAILS, ctlvs);
+ if (!ctlv) {
+ this.sendStkTerminalResponse({
+ resultCode: STK_RESULT_CMD_DATA_NOT_UNDERSTOOD});
+ throw new Error("Can't find COMMAND_DETAILS ComprehensionTlv");
+ }
+
+ let cmdDetails = ctlv.value;
+ if (DEBUG) {
+ this.context.debug("commandNumber = " + cmdDetails.commandNumber +
+ " typeOfCommand = " + cmdDetails.typeOfCommand.toString(16) +
+ " commandQualifier = " + cmdDetails.commandQualifier);
+ }
+
+ // STK_CMD_MORE_TIME need not to propagate event to chrome.
+ if (cmdDetails.typeOfCommand == STK_CMD_MORE_TIME) {
+ this.sendStkTerminalResponse({
+ command: cmdDetails,
+ resultCode: STK_RESULT_OK});
+ return;
+ }
+
+ this.context.StkCommandParamsFactory.createParam(cmdDetails,
+ ctlvs,
+ (aResult) => {
+ cmdDetails.options = aResult;
+ cmdDetails.rilMessageType = "stkcommand";
+ this.sendChromeMessage(cmdDetails);
+ });
+ },
+
+ sendDefaultResponse: function(options) {
+ if (!options.rilMessageType) {
+ return;
+ }
+
+ this.sendChromeMessage(options);
+ },
+
+ /**
+ * Send messages to the main thread.
+ */
+ sendChromeMessage: function(message) {
+ message.rilMessageClientId = this.context.clientId;
+ postMessage(message);
+ },
+
+ /**
+ * Handle incoming requests from the RIL. We find the method that
+ * corresponds to the request type. Incidentally, the request type
+ * _is_ the method name, so that's easy.
+ */
+
+ handleParcel: function(request_type, length, options) {
+ let method = this[request_type];
+ if (typeof method == "function") {
+ if (DEBUG) this.context.debug("Handling parcel as " + method.name);
+ method.call(this, length, options);
+ }
+
+ if (this.telephonyRequestQueue.isValidRequest(request_type)) {
+ this.telephonyRequestQueue.pop(request_type);
+ }
+ }
+};
+
+RilObject.prototype[REQUEST_GET_SIM_STATUS] = function REQUEST_GET_SIM_STATUS(length, options) {
+ if (options.errorMsg) {
+ return;
+ }
+
+ let iccStatus = {};
+ let Buf = this.context.Buf;
+ iccStatus.cardState = Buf.readInt32(); // CARD_STATE_*
+ iccStatus.universalPINState = Buf.readInt32(); // CARD_PINSTATE_*
+ iccStatus.gsmUmtsSubscriptionAppIndex = Buf.readInt32();
+ iccStatus.cdmaSubscriptionAppIndex = Buf.readInt32();
+ iccStatus.imsSubscriptionAppIndex = Buf.readInt32();
+
+ let apps_length = Buf.readInt32();
+ if (apps_length > CARD_MAX_APPS) {
+ apps_length = CARD_MAX_APPS;
+ }
+
+ iccStatus.apps = [];
+ for (let i = 0 ; i < apps_length ; i++) {
+ iccStatus.apps.push({
+ app_type: Buf.readInt32(), // CARD_APPTYPE_*
+ app_state: Buf.readInt32(), // CARD_APPSTATE_*
+ perso_substate: Buf.readInt32(), // CARD_PERSOSUBSTATE_*
+ aid: Buf.readString(),
+ app_label: Buf.readString(),
+ pin1_replaced: Buf.readInt32(),
+ pin1: Buf.readInt32(),
+ pin2: Buf.readInt32()
+ });
+ if (RILQUIRKS_SIM_APP_STATE_EXTRA_FIELDS) {
+ Buf.readInt32();
+ Buf.readInt32();
+ Buf.readInt32();
+ Buf.readInt32();
+ }
+ }
+
+ if (DEBUG) this.context.debug("iccStatus: " + JSON.stringify(iccStatus));
+ this._processICCStatus(iccStatus);
+};
+RilObject.prototype[REQUEST_ENTER_SIM_PIN] = function REQUEST_ENTER_SIM_PIN(length, options) {
+ this._processEnterAndChangeICCResponses(length, options);
+};
+RilObject.prototype[REQUEST_ENTER_SIM_PUK] = function REQUEST_ENTER_SIM_PUK(length, options) {
+ this._processEnterAndChangeICCResponses(length, options);
+};
+RilObject.prototype[REQUEST_ENTER_SIM_PIN2] = function REQUEST_ENTER_SIM_PIN2(length, options) {
+ this._processEnterAndChangeICCResponses(length, options);
+};
+RilObject.prototype[REQUEST_ENTER_SIM_PUK2] = function REQUEST_ENTER_SIM_PUK(length, options) {
+ this._processEnterAndChangeICCResponses(length, options);
+};
+RilObject.prototype[REQUEST_CHANGE_SIM_PIN] = function REQUEST_CHANGE_SIM_PIN(length, options) {
+ this._processEnterAndChangeICCResponses(length, options);
+};
+RilObject.prototype[REQUEST_CHANGE_SIM_PIN2] = function REQUEST_CHANGE_SIM_PIN2(length, options) {
+ this._processEnterAndChangeICCResponses(length, options);
+};
+RilObject.prototype[REQUEST_ENTER_NETWORK_DEPERSONALIZATION_CODE] =
+ function REQUEST_ENTER_NETWORK_DEPERSONALIZATION_CODE(length, options) {
+ this._processEnterAndChangeICCResponses(length, options);
+};
+RilObject.prototype[REQUEST_GET_CURRENT_CALLS] = function REQUEST_GET_CURRENT_CALLS(length, options) {
+ // Retry getCurrentCalls several times when error occurs.
+ if (options.errorMsg) {
+ if (this._getCurrentCallsRetryCount < GET_CURRENT_CALLS_RETRY_MAX) {
+ this._getCurrentCallsRetryCount++;
+ this.getCurrentCalls(options);
+ } else {
+ this.sendDefaultResponse(options);
+ }
+ return;
+ }
+
+ this._getCurrentCallsRetryCount = 0;
+
+ let Buf = this.context.Buf;
+ let calls_length = 0;
+ // The RIL won't even send us the length integer if there are no active calls.
+ // So only read this integer if the parcel actually has it.
+ if (length) {
+ calls_length = Buf.readInt32();
+ }
+
+ let calls = {};
+ for (let i = 0; i < calls_length; i++) {
+ let call = {};
+
+ // Extra uint32 field to get correct callIndex and rest of call data for
+ // call waiting feature.
+ if (RILQUIRKS_EXTRA_UINT32_2ND_CALL && i > 0) {
+ Buf.readInt32();
+ }
+
+ call.state = Buf.readInt32(); // CALL_STATE_*
+ call.callIndex = Buf.readInt32(); // GSM index (1-based)
+ call.toa = Buf.readInt32();
+ call.isMpty = Boolean(Buf.readInt32());
+ call.isMT = Boolean(Buf.readInt32());
+ call.als = Buf.readInt32();
+ call.isVoice = Boolean(Buf.readInt32());
+ call.isVoicePrivacy = Boolean(Buf.readInt32());
+ if (RILQUIRKS_CALLSTATE_EXTRA_UINT32) {
+ Buf.readInt32();
+ }
+ call.number = Buf.readString();
+ call.numberPresentation = Buf.readInt32(); // CALL_PRESENTATION_*
+ call.name = Buf.readString();
+ call.namePresentation = Buf.readInt32();
+
+ call.uusInfo = null;
+ let uusInfoPresent = Buf.readInt32();
+ if (uusInfoPresent == 1) {
+ call.uusInfo = {
+ type: Buf.readInt32(),
+ dcs: Buf.readInt32(),
+ userData: null //XXX TODO byte array?!?
+ };
+ }
+
+ if (call.isVoice) {
+ calls[call.callIndex] = call;
+ }
+ }
+
+ options.calls = calls;
+ options.rilMessageType = options.rilMessageType || "currentCalls";
+ this.sendChromeMessage(options);
+};
+RilObject.prototype[REQUEST_DIAL] = function REQUEST_DIAL(length, options) {
+ this.sendDefaultResponse(options);
+};
+RilObject.prototype[REQUEST_DIAL_EMERGENCY_CALL] = function REQUEST_DIAL_EMERGENCY_CALL(length, options) {
+ RilObject.prototype[REQUEST_DIAL].call(this, length, options);
+};
+RilObject.prototype[REQUEST_GET_IMSI] = function REQUEST_GET_IMSI(length, options) {
+ if (options.errorMsg) {
+ return;
+ }
+
+ this.iccInfoPrivate.imsi = this.context.Buf.readString();
+ if (DEBUG) {
+ this.context.debug("IMSI: " + this.iccInfoPrivate.imsi);
+ }
+
+ options.rilMessageType = "iccimsi";
+ options.imsi = this.iccInfoPrivate.imsi;
+ this.sendChromeMessage(options);
+};
+RilObject.prototype[REQUEST_HANGUP] = function REQUEST_HANGUP(length, options) {
+ this.sendDefaultResponse(options);
+};
+RilObject.prototype[REQUEST_HANGUP_WAITING_OR_BACKGROUND] = function REQUEST_HANGUP_WAITING_OR_BACKGROUND(length, options) {
+ this.sendDefaultResponse(options);
+};
+RilObject.prototype[REQUEST_HANGUP_FOREGROUND_RESUME_BACKGROUND] = function REQUEST_HANGUP_FOREGROUND_RESUME_BACKGROUND(length, options) {
+ this.sendDefaultResponse(options);
+};
+RilObject.prototype[REQUEST_SWITCH_WAITING_OR_HOLDING_AND_ACTIVE] = function REQUEST_SWITCH_WAITING_OR_HOLDING_AND_ACTIVE(length, options) {
+ this.sendDefaultResponse(options);
+};
+RilObject.prototype[REQUEST_CONFERENCE] = function REQUEST_CONFERENCE(length, options) {
+ this.sendDefaultResponse(options);
+};
+RilObject.prototype[REQUEST_UDUB] = function REQUEST_UDUB(length, options) {
+ this.sendDefaultResponse(options);
+};
+RilObject.prototype[REQUEST_LAST_CALL_FAIL_CAUSE] = function REQUEST_LAST_CALL_FAIL_CAUSE(length, options) {
+ // Treat it as CALL_FAIL_ERROR_UNSPECIFIED if the request failed.
+ let failCause = CALL_FAIL_ERROR_UNSPECIFIED;
+
+ if (!options.errorMsg) {
+ let Buf = this.context.Buf;
+ let num = length ? Buf.readInt32() : 0;
+
+ if (num) {
+ let causeNum = Buf.readInt32();
+ failCause = RIL_CALL_FAILCAUSE_TO_GECKO_CALL_ERROR[causeNum] || failCause;
+ }
+ if (DEBUG) this.context.debug("Last call fail cause: " + failCause);
+ }
+
+ options.failCause = failCause;
+ this.sendChromeMessage(options);
+};
+RilObject.prototype[REQUEST_SIGNAL_STRENGTH] = function REQUEST_SIGNAL_STRENGTH(length, options) {
+ this._receivedNetworkInfo(NETWORK_INFO_SIGNAL);
+
+ if (options.errorMsg) {
+ return;
+ }
+
+ let Buf = this.context.Buf;
+ let signal = {};
+
+ signal.gsmSignalStrength = Buf.readInt32();
+ signal.gsmBitErrorRate = Buf.readInt32();
+ if (RILQUIRKS_SIGNAL_EXTRA_INT32) {
+ Buf.readInt32();
+ }
+ signal.cdmaDBM = Buf.readInt32();
+ signal.cdmaECIO = Buf.readInt32();
+ signal.evdoDBM = Buf.readInt32();
+ signal.evdoECIO = Buf.readInt32();
+ signal.evdoSNR = Buf.readInt32();
+
+ signal.lteSignalStrength = Buf.readInt32();
+ signal.lteRSRP = Buf.readInt32();
+ signal.lteRSRQ = Buf.readInt32();
+ signal.lteRSSNR = Buf.readInt32();
+ signal.lteCQI = Buf.readInt32();
+
+ if (DEBUG) this.context.debug("signal strength: " + JSON.stringify(signal));
+
+ this._processSignalStrength(signal);
+};
+RilObject.prototype[REQUEST_VOICE_REGISTRATION_STATE] = function REQUEST_VOICE_REGISTRATION_STATE(length, options) {
+ this._receivedNetworkInfo(NETWORK_INFO_VOICE_REGISTRATION_STATE);
+
+ if (options.errorMsg) {
+ return;
+ }
+
+ let state = this.context.Buf.readStringList();
+ if (DEBUG) this.context.debug("voice registration state: " + state);
+
+ this._processVoiceRegistrationState(state);
+};
+RilObject.prototype[REQUEST_DATA_REGISTRATION_STATE] = function REQUEST_DATA_REGISTRATION_STATE(length, options) {
+ this._receivedNetworkInfo(NETWORK_INFO_DATA_REGISTRATION_STATE);
+
+ if (options.errorMsg) {
+ return;
+ }
+
+ let state = this.context.Buf.readStringList();
+ this._processDataRegistrationState(state);
+};
+RilObject.prototype[REQUEST_OPERATOR] = function REQUEST_OPERATOR(length, options) {
+ this._receivedNetworkInfo(NETWORK_INFO_OPERATOR);
+
+ if (options.errorMsg) {
+ return;
+ }
+
+ let operatorData = this.context.Buf.readStringList();
+ if (DEBUG) this.context.debug("Operator: " + operatorData);
+ this._processOperator(operatorData);
+};
+RilObject.prototype[REQUEST_RADIO_POWER] = function REQUEST_RADIO_POWER(length, options) {
+ this.sendDefaultResponse(options);
+};
+RilObject.prototype[REQUEST_DTMF] = null;
+RilObject.prototype[REQUEST_SEND_SMS] = function REQUEST_SEND_SMS(length, options) {
+ this._processSmsSendResult(length, options);
+};
+RilObject.prototype[REQUEST_SEND_SMS_EXPECT_MORE] = null;
+
+RilObject.prototype[REQUEST_SETUP_DATA_CALL] = function REQUEST_SETUP_DATA_CALL(length, options) {
+ if (options.errorMsg) {
+ this.sendChromeMessage(options);
+ return;
+ }
+
+ let Buf = this.context.Buf;
+ let version = Buf.readInt32();
+ // Skip number of data calls.
+ Buf.readInt32();
+
+ this.readDataCall(options, version);
+ this.sendChromeMessage(options);
+};
+RilObject.prototype[REQUEST_SIM_IO] = function REQUEST_SIM_IO(length, options) {
+ if (options.errorMsg) {
+ if (options.onerror) {
+ options.onerror(options.errorMsg);
+ }
+ return;
+ }
+
+ let Buf = this.context.Buf;
+ options.sw1 = Buf.readInt32();
+ options.sw2 = Buf.readInt32();
+
+ // See 3GPP TS 11.11, clause 9.4.1 for operation success results.
+ if (options.sw1 !== ICC_STATUS_NORMAL_ENDING &&
+ options.sw1 !== ICC_STATUS_NORMAL_ENDING_WITH_EXTRA &&
+ options.sw1 !== ICC_STATUS_WITH_SIM_DATA &&
+ options.sw1 !== ICC_STATUS_WITH_RESPONSE_DATA) {
+ if (DEBUG) {
+ this.context.debug("ICC I/O Error EF id = 0x" + options.fileId.toString(16) +
+ ", command = 0x" + options.command.toString(16) +
+ ", sw1 = 0x" + options.sw1.toString(16) +
+ ", sw2 = 0x" + options.sw2.toString(16));
+ }
+ if (options.onerror) {
+ // We can get fail cause from sw1/sw2 (See TS 11.11 clause 9.4.1 and
+ // ISO 7816-4 clause 6). But currently no one needs this information,
+ // so simply reports "GenericFailure" for now.
+ options.onerror(GECKO_ERROR_GENERIC_FAILURE);
+ }
+ return;
+ }
+ this.context.ICCIOHelper.processICCIO(options);
+};
+RilObject.prototype[REQUEST_SEND_USSD] = function REQUEST_SEND_USSD(length, options) {
+ if (DEBUG) {
+ this.context.debug("REQUEST_SEND_USSD " + JSON.stringify(options));
+ }
+ this.sendChromeMessage(options);
+};
+RilObject.prototype[REQUEST_CANCEL_USSD] = function REQUEST_CANCEL_USSD(length, options) {
+ if (DEBUG) {
+ this.context.debug("REQUEST_CANCEL_USSD" + JSON.stringify(options));
+ }
+ this.sendChromeMessage(options);
+};
+RilObject.prototype[REQUEST_GET_CLIR] = function REQUEST_GET_CLIR(length, options) {
+ if (options.errorMsg) {
+ this.sendChromeMessage(options);
+ return;
+ }
+
+ let Buf = this.context.Buf;
+ let bufLength = Buf.readInt32();
+ if (!bufLength || bufLength < 2) {
+ options.errorMsg = GECKO_ERROR_GENERIC_FAILURE;
+ this.sendChromeMessage(options);
+ return;
+ }
+
+ options.n = Buf.readInt32(); // Will be TS 27.007 +CLIR parameter 'n'.
+ options.m = Buf.readInt32(); // Will be TS 27.007 +CLIR parameter 'm'.
+ this.sendChromeMessage(options);
+};
+RilObject.prototype[REQUEST_SET_CLIR] = function REQUEST_SET_CLIR(length, options) {
+ if (options.rilMessageType == null) {
+ // The request was made by ril_worker itself automatically. Don't report.
+ return;
+ }
+
+ this.sendChromeMessage(options);
+};
+
+RilObject.prototype[REQUEST_QUERY_CALL_FORWARD_STATUS] =
+ function REQUEST_QUERY_CALL_FORWARD_STATUS(length, options) {
+ if (options.errorMsg) {
+ this.sendChromeMessage(options);
+ return;
+ }
+
+ let Buf = this.context.Buf;
+ let rulesLength = 0;
+ if (length) {
+ rulesLength = Buf.readInt32();
+ }
+ if (!rulesLength) {
+ options.errorMsg = GECKO_ERROR_GENERIC_FAILURE;
+ this.sendChromeMessage(options);
+ return;
+ }
+ let rules = new Array(rulesLength);
+ for (let i = 0; i < rulesLength; i++) {
+ let rule = {};
+ rule.active = Buf.readInt32() == 1; // CALL_FORWARD_STATUS_*
+ rule.reason = Buf.readInt32(); // CALL_FORWARD_REASON_*
+ rule.serviceClass = Buf.readInt32();
+ rule.toa = Buf.readInt32();
+ rule.number = Buf.readString();
+ rule.timeSeconds = Buf.readInt32();
+ rules[i] = rule;
+ }
+ options.rules = rules;
+ this.sendChromeMessage(options);
+};
+RilObject.prototype[REQUEST_SET_CALL_FORWARD] =
+ function REQUEST_SET_CALL_FORWARD(length, options) {
+ this.sendChromeMessage(options);
+};
+RilObject.prototype[REQUEST_QUERY_CALL_WAITING] =
+ function REQUEST_QUERY_CALL_WAITING(length, options) {
+ if (options.errorMsg) {
+ this.sendChromeMessage(options);
+ return;
+ }
+
+ let Buf = this.context.Buf;
+ let results = Buf.readInt32List();
+ let enabled = (results[0] === 1);
+ options.serviceClass = enabled ? results[1] : ICC_SERVICE_CLASS_NONE;
+ this.sendChromeMessage(options);
+};
+
+RilObject.prototype[REQUEST_SET_CALL_WAITING] = function REQUEST_SET_CALL_WAITING(length, options) {
+ this.sendChromeMessage(options);
+};
+RilObject.prototype[REQUEST_SMS_ACKNOWLEDGE] = null;
+RilObject.prototype[REQUEST_GET_IMEI] = null;
+RilObject.prototype[REQUEST_GET_IMEISV] = null;
+RilObject.prototype[REQUEST_ANSWER] = function REQUEST_ANSWER(length, options) {
+ this.sendDefaultResponse(options);
+};
+RilObject.prototype[REQUEST_DEACTIVATE_DATA_CALL] = function REQUEST_DEACTIVATE_DATA_CALL(length, options) {
+ this.sendChromeMessage(options);
+};
+RilObject.prototype[REQUEST_QUERY_FACILITY_LOCK] = function REQUEST_QUERY_FACILITY_LOCK(length, options) {
+ if (options.errorMsg) {
+ this.sendChromeMessage(options);
+ return;
+ }
+
+ if (!length) {
+ options.errorMsg = GECKO_ERROR_GENERIC_FAILURE;
+ this.sendChromeMessage(options);
+ return;
+ }
+
+ // Buf.readInt32List()[0] for Call Barring is a bit vector of services.
+ options.serviceClass = this.context.Buf.readInt32List()[0];
+ if (options.queryServiceClass) {
+ options.enabled = (options.serviceClass & options.queryServiceClass) ? true : false;
+ options.serviceClass = options.queryServiceClass;
+ } else {
+ options.enabled = options.serviceClass ? true : false;
+ }
+
+ this.sendChromeMessage(options);
+};
+RilObject.prototype[REQUEST_SET_FACILITY_LOCK] = function REQUEST_SET_FACILITY_LOCK(length, options) {
+ options.retryCount = length ? this.context.Buf.readInt32List()[0] : -1;
+ this.sendChromeMessage(options);
+};
+RilObject.prototype[REQUEST_CHANGE_BARRING_PASSWORD] =
+ function REQUEST_CHANGE_BARRING_PASSWORD(length, options) {
+ this.sendChromeMessage(options);
+};
+RilObject.prototype[REQUEST_QUERY_NETWORK_SELECTION_MODE] = function REQUEST_QUERY_NETWORK_SELECTION_MODE(length, options) {
+ this._receivedNetworkInfo(NETWORK_INFO_NETWORK_SELECTION_MODE);
+
+ if (options.errorMsg) {
+ return;
+ }
+
+ let mode = this.context.Buf.readInt32List();
+ let selectionMode;
+
+ switch (mode[0]) {
+ case NETWORK_SELECTION_MODE_AUTOMATIC:
+ selectionMode = GECKO_NETWORK_SELECTION_AUTOMATIC;
+ break;
+ case NETWORK_SELECTION_MODE_MANUAL:
+ selectionMode = GECKO_NETWORK_SELECTION_MANUAL;
+ break;
+ default:
+ selectionMode = GECKO_NETWORK_SELECTION_UNKNOWN;
+ break;
+ }
+
+ this._updateNetworkSelectionMode(selectionMode);
+};
+RilObject.prototype[REQUEST_SET_NETWORK_SELECTION_AUTOMATIC] = function REQUEST_SET_NETWORK_SELECTION_AUTOMATIC(length, options) {
+ if (!options.errorMsg) {
+ this._updateNetworkSelectionMode(GECKO_NETWORK_SELECTION_AUTOMATIC);
+ }
+ this.sendChromeMessage(options);
+};
+RilObject.prototype[REQUEST_SET_NETWORK_SELECTION_MANUAL] = function REQUEST_SET_NETWORK_SELECTION_MANUAL(length, options) {
+ if (!options.errorMsg) {
+ this._updateNetworkSelectionMode(GECKO_NETWORK_SELECTION_MANUAL);
+ }
+ this.sendChromeMessage(options);
+};
+RilObject.prototype[REQUEST_QUERY_AVAILABLE_NETWORKS] = function REQUEST_QUERY_AVAILABLE_NETWORKS(length, options) {
+ if (!options.errorMsg) {
+ options.networks = this._processNetworks();
+ }
+ this.sendChromeMessage(options);
+};
+RilObject.prototype[REQUEST_DTMF_START] = function REQUEST_DTMF_START(length, options) {
+ this.sendChromeMessage(options);
+};
+RilObject.prototype[REQUEST_DTMF_STOP] = null;
+RilObject.prototype[REQUEST_BASEBAND_VERSION] = function REQUEST_BASEBAND_VERSION(length, options) {
+ if (options.errorMsg) {
+ return;
+ }
+
+ this.basebandVersion = this.context.Buf.readString();
+ if (DEBUG) this.context.debug("Baseband version: " + this.basebandVersion);
+};
+RilObject.prototype[REQUEST_SEPARATE_CONNECTION] = function REQUEST_SEPARATE_CONNECTION(length, options) {
+ this.sendDefaultResponse(options);
+};
+RilObject.prototype[REQUEST_SET_MUTE] = null;
+RilObject.prototype[REQUEST_GET_MUTE] = null;
+RilObject.prototype[REQUEST_QUERY_CLIP] = function REQUEST_QUERY_CLIP(length, options) {
+ if (options.errorMsg) {
+ this.sendChromeMessage(options);
+ return;
+ }
+
+ let Buf = this.context.Buf;
+ let bufLength = Buf.readInt32();
+ if (!bufLength) {
+ options.errorMsg = GECKO_ERROR_GENERIC_FAILURE;
+ this.sendChromeMessage(options);
+ return;
+ }
+
+ options.provisioned = Buf.readInt32();
+ this.sendChromeMessage(options);
+};
+RilObject.prototype[REQUEST_LAST_DATA_CALL_FAIL_CAUSE] = null;
+
+/**
+ * V6:
+ * # addresses - A space-delimited list of addresses with optional "/" prefix
+ * length.
+ * # dnses - A space-delimited list of DNS server addresses.
+ * # gateways - A space-delimited list of default gateway addresses.
+ *
+ * V10:
+ * # pcscf - A space-delimited list of Proxy Call State Control Function
+ * addresses.
+ */
+
+RilObject.prototype.readDataCall = function(options, version) {
+ if (!options) {
+ options = {};
+ }
+ let Buf = this.context.Buf;
+ options.failCause = Buf.readInt32(); // DATACALL_FAIL_*
+ options.suggestedRetryTime = Buf.readInt32();
+ options.cid = Buf.readInt32().toString();
+ options.active = Buf.readInt32(); // DATACALL_ACTIVE_*
+ options.type = Buf.readString();
+ options.ifname = Buf.readString();
+ options.addresses = Buf.readString();
+ options.dnses = Buf.readString();
+ options.gateways = Buf.readString();
+
+ if (version >= 10) {
+ options.pcscf = Buf.readString();
+ }
+
+ if (version >= 11) {
+ let mtu = Buf.readInt32();
+ options.mtu = (mtu > 0) ? mtu : -1 ;
+ }
+
+ return options;
+};
+
+RilObject.prototype[REQUEST_DATA_CALL_LIST] = function REQUEST_DATA_CALL_LIST(length, options) {
+ if (options.errorMsg) {
+ if (options.rilMessageType) {
+ this.sendChromeMessage(options);
+ }
+ return;
+ }
+
+ if (!options.rilMessageType) {
+ // This is an unsolicited data call list changed.
+ options.rilMessageType = "datacalllistchanged";
+ }
+
+ if (!length) {
+ options.datacalls = [];
+ this.sendChromeMessage(options);
+ return;
+ }
+
+ let Buf = this.context.Buf;
+ let version = Buf.readInt32();
+ let num = Buf.readInt32();
+ let datacalls = [];
+ for (let i = 0; i < num; i++) {
+ let datacall;
+ datacall = this.readDataCall({}, version);
+ datacalls.push(datacall);
+ }
+
+ options.datacalls = datacalls;
+ this.sendChromeMessage(options);
+};
+RilObject.prototype[REQUEST_RESET_RADIO] = null;
+RilObject.prototype[REQUEST_OEM_HOOK_RAW] = null;
+RilObject.prototype[REQUEST_OEM_HOOK_STRINGS] = null;
+RilObject.prototype[REQUEST_SCREEN_STATE] = null;
+RilObject.prototype[REQUEST_SET_SUPP_SVC_NOTIFICATION] = null;
+RilObject.prototype[REQUEST_WRITE_SMS_TO_SIM] = function REQUEST_WRITE_SMS_TO_SIM(length, options) {
+ if (options.errorMsg) {
+ // `The MS shall return a "protocol error, unspecified" error message if
+ // the short message cannot be stored in the (U)SIM, and there is other
+ // message storage available at the MS` ~ 3GPP TS 23.038 section 4. Here
+ // we assume we always have indexed db as another storage.
+ this.acknowledgeGsmSms(false, PDU_FCS_PROTOCOL_ERROR);
+ } else {
+ this.acknowledgeGsmSms(true, PDU_FCS_OK);
+ }
+};
+RilObject.prototype[REQUEST_DELETE_SMS_ON_SIM] = null;
+RilObject.prototype[REQUEST_SET_BAND_MODE] = null;
+RilObject.prototype[REQUEST_QUERY_AVAILABLE_BAND_MODE] = null;
+RilObject.prototype[REQUEST_STK_GET_PROFILE] = null;
+RilObject.prototype[REQUEST_STK_SET_PROFILE] = null;
+RilObject.prototype[REQUEST_STK_SEND_ENVELOPE_COMMAND] = null;
+RilObject.prototype[REQUEST_STK_SEND_TERMINAL_RESPONSE] = null;
+RilObject.prototype[REQUEST_STK_HANDLE_CALL_SETUP_REQUESTED_FROM_SIM] = null;
+RilObject.prototype[REQUEST_EXPLICIT_CALL_TRANSFER] = null;
+RilObject.prototype[REQUEST_SET_PREFERRED_NETWORK_TYPE] = function REQUEST_SET_PREFERRED_NETWORK_TYPE(length, options) {
+ this.sendChromeMessage(options);
+};
+RilObject.prototype[REQUEST_GET_PREFERRED_NETWORK_TYPE] = function REQUEST_GET_PREFERRED_NETWORK_TYPE(length, options) {
+ if (options.errorMsg) {
+ this.sendChromeMessage(options);
+ return;
+ }
+
+ options.type = this.context.Buf.readInt32List()[0];
+ this.sendChromeMessage(options);
+};
+RilObject.prototype[REQUEST_GET_NEIGHBORING_CELL_IDS] = function REQUEST_GET_NEIGHBORING_CELL_IDS(length, options) {
+ if (options.errorMsg) {
+ this.sendChromeMessage(options);
+ return;
+ }
+
+ let radioTech = this.voiceRegistrationState.radioTech;
+ if (radioTech == undefined || radioTech == NETWORK_CREG_TECH_UNKNOWN) {
+ options.errorMsg = "RadioTechUnavailable";
+ this.sendChromeMessage(options);
+ return;
+ }
+ if (!this._isGsmTechGroup(radioTech) || radioTech == NETWORK_CREG_TECH_LTE) {
+ options.errorMsg = "UnsupportedRadioTech";
+ this.sendChromeMessage(options);
+ return;
+ }
+
+ let Buf = this.context.Buf;
+ let neighboringCellIds = [];
+ let num = Buf.readInt32();
+
+ for (let i = 0; i < num; i++) {
+ let cellId = {};
+ cellId.networkType = GECKO_RADIO_TECH[radioTech];
+ cellId.signalStrength = Buf.readInt32();
+
+ let cid = Buf.readString();
+ // pad cid string with leading "0"
+ let length = cid.length;
+ if (length > 8) {
+ continue;
+ }
+ if (length < 8) {
+ for (let j = 0; j < (8-length); j++) {
+ cid = "0" + cid;
+ }
+ }
+
+ switch (radioTech) {
+ case NETWORK_CREG_TECH_GPRS:
+ case NETWORK_CREG_TECH_EDGE:
+ case NETWORK_CREG_TECH_GSM:
+ cellId.gsmCellId = this.parseInt(cid.substring(4), -1, 16);
+ cellId.gsmLocationAreaCode = this.parseInt(cid.substring(0, 4), -1, 16);
+ break;
+ case NETWORK_CREG_TECH_UMTS:
+ case NETWORK_CREG_TECH_HSDPA:
+ case NETWORK_CREG_TECH_HSUPA:
+ case NETWORK_CREG_TECH_HSPA:
+ case NETWORK_CREG_TECH_HSPAP:
+ case NETWORK_CREG_TECH_DCHSPAP_1:
+ case NETWORK_CREG_TECH_DCHSPAP_2:
+ cellId.wcdmaPsc = this.parseInt(cid, -1, 16);
+ break;
+ }
+
+ neighboringCellIds.push(cellId);
+ }
+
+ options.result = neighboringCellIds;
+ this.sendChromeMessage(options);
+};
+RilObject.prototype[REQUEST_GET_CELL_INFO_LIST] = function REQUEST_GET_CELL_INFO_LIST(length, options) {
+ if (options.errorMsg) {
+ this.sendChromeMessage(options);
+ return;
+ }
+
+ let Buf = this.context.Buf;
+ let cellInfoList = [];
+ let num = Buf.readInt32();
+ for (let i = 0; i < num; i++) {
+ let cellInfo = {};
+ cellInfo.type = Buf.readInt32();
+ cellInfo.registered = Buf.readInt32() ? true : false;
+ cellInfo.timestampType = Buf.readInt32();
+ cellInfo.timestamp = Buf.readInt64();
+
+ switch(cellInfo.type) {
+ case CELL_INFO_TYPE_GSM:
+ case CELL_INFO_TYPE_WCDMA:
+ cellInfo.mcc = Buf.readInt32();
+ cellInfo.mnc = Buf.readInt32();
+ cellInfo.lac = Buf.readInt32();
+ cellInfo.cid = Buf.readInt32();
+ if (cellInfo.type == CELL_INFO_TYPE_WCDMA) {
+ cellInfo.psc = Buf.readInt32();
+ }
+ cellInfo.signalStrength = Buf.readInt32();
+ cellInfo.bitErrorRate = Buf.readInt32();
+ break;
+ case CELL_INFO_TYPE_CDMA:
+ cellInfo.networkId = Buf.readInt32();
+ cellInfo.systemId = Buf.readInt32();
+ cellInfo.basestationId = Buf.readInt32();
+ cellInfo.longitude = Buf.readInt32();
+ cellInfo.latitude = Buf.readInt32();
+ cellInfo.cdmaDbm = Buf.readInt32();
+ cellInfo.cdmaEcio = Buf.readInt32();
+ cellInfo.evdoDbm = Buf.readInt32();
+ cellInfo.evdoEcio = Buf.readInt32();
+ cellInfo.evdoSnr = Buf.readInt32();
+ break;
+ case CELL_INFO_TYPE_LTE:
+ cellInfo.mcc = Buf.readInt32();
+ cellInfo.mnc = Buf.readInt32();
+ cellInfo.cid = Buf.readInt32();
+ cellInfo.pcid = Buf.readInt32();
+ cellInfo.tac = Buf.readInt32();
+ cellInfo.signalStrength = Buf.readInt32();
+ cellInfo.rsrp = Buf.readInt32();
+ cellInfo.rsrq = Buf.readInt32();
+ cellInfo.rssnr = Buf.readInt32();
+ cellInfo.cqi = Buf.readInt32();
+ break;
+ }
+ cellInfoList.push(cellInfo);
+ }
+ options.result = cellInfoList;
+ this.sendChromeMessage(options);
+};
+RilObject.prototype[REQUEST_SET_LOCATION_UPDATES] = null;
+RilObject.prototype[REQUEST_CDMA_SET_SUBSCRIPTION_SOURCE] = null;
+RilObject.prototype[REQUEST_CDMA_SET_ROAMING_PREFERENCE] = function REQUEST_CDMA_SET_ROAMING_PREFERENCE(length, options) {
+ this.sendChromeMessage(options);
+};
+RilObject.prototype[REQUEST_CDMA_QUERY_ROAMING_PREFERENCE] = function REQUEST_CDMA_QUERY_ROAMING_PREFERENCE(length, options) {
+ if (!options.errorMsg) {
+ options.mode = this.context.Buf.readInt32List()[0];
+ }
+ this.sendChromeMessage(options);
+};
+RilObject.prototype[REQUEST_SET_TTY_MODE] = null;
+RilObject.prototype[REQUEST_QUERY_TTY_MODE] = null;
+RilObject.prototype[REQUEST_CDMA_SET_PREFERRED_VOICE_PRIVACY_MODE] = function REQUEST_CDMA_SET_PREFERRED_VOICE_PRIVACY_MODE(length, options) {
+ this.sendChromeMessage(options);
+};
+RilObject.prototype[REQUEST_CDMA_QUERY_PREFERRED_VOICE_PRIVACY_MODE] = function REQUEST_CDMA_QUERY_PREFERRED_VOICE_PRIVACY_MODE(length, options) {
+ if (options.errorMsg) {
+ this.sendChromeMessage(options);
+ return;
+ }
+
+ let enabled = this.context.Buf.readInt32List();
+ options.enabled = enabled[0] ? true : false;
+ this.sendChromeMessage(options);
+};
+RilObject.prototype[REQUEST_CDMA_FLASH] = function REQUEST_CDMA_FLASH(length, options) {
+ this.sendDefaultResponse(options);
+};
+RilObject.prototype[REQUEST_CDMA_BURST_DTMF] = null;
+RilObject.prototype[REQUEST_CDMA_VALIDATE_AND_WRITE_AKEY] = null;
+RilObject.prototype[REQUEST_CDMA_SEND_SMS] = function REQUEST_CDMA_SEND_SMS(length, options) {
+ this._processSmsSendResult(length, options);
+};
+RilObject.prototype[REQUEST_CDMA_SMS_ACKNOWLEDGE] = null;
+RilObject.prototype[REQUEST_GSM_GET_BROADCAST_SMS_CONFIG] = null;
+RilObject.prototype[REQUEST_GSM_SET_BROADCAST_SMS_CONFIG] = function REQUEST_GSM_SET_BROADCAST_SMS_CONFIG(length, options) {
+ if (options.errorMsg) {
+ return;
+ }
+ this.setSmsBroadcastActivation(true);
+};
+RilObject.prototype[REQUEST_GSM_SMS_BROADCAST_ACTIVATION] = null;
+RilObject.prototype[REQUEST_CDMA_GET_BROADCAST_SMS_CONFIG] = null;
+RilObject.prototype[REQUEST_CDMA_SET_BROADCAST_SMS_CONFIG] = function REQUEST_CDMA_SET_BROADCAST_SMS_CONFIG(length, options) {
+ if (options.errorMsg) {
+ return;
+ }
+ this.setSmsBroadcastActivation(true);
+};
+RilObject.prototype[REQUEST_CDMA_SMS_BROADCAST_ACTIVATION] = null;
+RilObject.prototype[REQUEST_CDMA_SUBSCRIPTION] = function REQUEST_CDMA_SUBSCRIPTION(length, options) {
+ if (options.errorMsg) {
+ return;
+ }
+
+ let result = this.context.Buf.readStringList();
+
+ this.iccInfo.mdn = result[0];
+ // The result[1] is Home SID. (Already be handled in readCDMAHome())
+ // The result[2] is Home NID. (Already be handled in readCDMAHome())
+ // The result[3] is MIN.
+ this.iccInfo.prlVersion = parseInt(result[4], 10);
+
+ this.context.ICCUtilsHelper.handleICCInfoChange();
+};
+RilObject.prototype[REQUEST_CDMA_WRITE_SMS_TO_RUIM] = null;
+RilObject.prototype[REQUEST_CDMA_DELETE_SMS_ON_RUIM] = null;
+RilObject.prototype[REQUEST_DEVICE_IDENTITY] = function REQUEST_DEVICE_IDENTITY(length, options) {
+ if (options.errorMsg) {
+ this.context.debug("Failed to get device identities:" + options.errorMsg);
+ return;
+ }
+
+ let result = this.context.Buf.readStringList();
+ this.deviceIdentities = {
+ imei: result[0] || null,
+ imeisv: result[1] || null,
+ esn: result[2] || null,
+ meid: result[3] || null,
+ };
+
+ this.sendChromeMessage({
+ rilMessageType: "deviceidentitieschange",
+ deviceIdentities: this.deviceIdentities
+ });
+};
+RilObject.prototype[REQUEST_EXIT_EMERGENCY_CALLBACK_MODE] = function REQUEST_EXIT_EMERGENCY_CALLBACK_MODE(length, options) {
+ if (options.internal) {
+ return;
+ }
+
+ this.sendChromeMessage(options);
+};
+RilObject.prototype[REQUEST_GET_SMSC_ADDRESS] = function REQUEST_GET_SMSC_ADDRESS(length, options) {
+ if (!options.rilMessageType || options.rilMessageType !== "getSmscAddress") {
+ return;
+ }
+
+ if (options.errorMsg) {
+ this.sendChromeMessage(options);
+ return;
+ }
+
+ let tosca = TOA_UNKNOWN;
+ let smsc = "";
+ let Buf = this.context.Buf;
+ if (RILQUIRKS_SMSC_ADDRESS_FORMAT === "pdu") {
+ let pduHelper = this.context.GsmPDUHelper;
+ let strlen = Buf.readInt32();
+ let length = pduHelper.readHexOctet();
+
+ // As defined in |8.2.5.2 Destination address element| of 3GPP TS 24.011,
+ // the value of length field can not exceed 11. Since the content might be
+ // filled with 12 'F' when SMSC is cleared, we don't parse the TOA and
+ // address fields if reported length exceeds 11 here. Instead, keep the
+ // default value (TOA_UNKNOWN with an empty address) in this case.
+ const MAX_LENGTH = 11
+ if (length <= MAX_LENGTH) {
+ tosca = pduHelper.readHexOctet();
+
+ // Read and covert the decimal values back to special BCD digits defined in
+ // |Called party BCD number| of 3GPP TS 24.008 (refer the following table).
+ //
+ // +=========+=======+=====+
+ // | value | digit | hex |
+ // +========================
+ // | 1 0 1 0 | * | 0xA |
+ // | 1 0 1 1 | # | 0xB |
+ // | 1 1 0 0 | a | 0xC |
+ // | 1 1 0 1 | b | 0xD |
+ // | 1 1 1 0 | c | 0xE |
+ // +=========+=======+=====+
+ smsc = pduHelper.readSwappedNibbleBcdString(length - 1, true)
+ .replace(/a/ig, "*")
+ .replace(/b/ig, "#")
+ .replace(/c/ig, "a")
+ .replace(/d/ig, "b")
+ .replace(/e/ig, "c");
+
+ Buf.readStringDelimiter(strlen);
+ }
+ } else /* RILQUIRKS_SMSC_ADDRESS_FORMAT === "text" */ {
+ let text = Buf.readString();
+ let segments = text.split(",", 2);
+ // Parse TOA only if it presents since some devices might omit the TOA
+ // segment in the reported SMSC address. If TOA does not present, keep the
+ // default value TOA_UNKNOWN.
+ if (segments.length === 2) {
+ tosca = this.parseInt(segments[1], TOA_UNKNOWN, 10);
+ }
+
+ smsc = segments[0].replace(/\"/g, "");
+ }
+
+ // Convert the NPI value to the corresponding index of CALLED_PARTY_BCD_NPI
+ // array. If the value does not present in the array, use
+ // CALLED_PARTY_BCD_NPI_ISDN.
+ let npi = CALLED_PARTY_BCD_NPI.indexOf(tosca & 0xf);
+ if (npi === -1) {
+ npi = CALLED_PARTY_BCD_NPI.indexOf(CALLED_PARTY_BCD_NPI_ISDN);
+ }
+
+ // Extract TON.
+ let ton = (tosca & 0x70) >> 4;
+
+ // Ensure + sign if TON is international, and vice versa.
+ const TON_INTERNATIONAL = (TOA_INTERNATIONAL & 0x70) >> 4;
+ if (ton === TON_INTERNATIONAL && smsc.charAt(0) !== "+") {
+ smsc = "+" + smsc;
+ } else if (smsc.charAt(0) === "+" && ton !== TON_INTERNATIONAL) {
+ if (DEBUG) {
+ this.context.debug("SMSC address number begins with '+' while the TON is not international. Change TON to international.");
+ }
+ ton = TON_INTERNATIONAL;
+ }
+
+ options.smscAddress = smsc;
+ options.typeOfNumber = ton;
+ options.numberPlanIdentification = npi;
+ this.sendChromeMessage(options);
+};
+RilObject.prototype[REQUEST_SET_SMSC_ADDRESS] = function REQUEST_SET_SMSC_ADDRESS(length, options) {
+ if (!options.rilMessageType || options.rilMessageType !== "setSmscAddress") {
+ return;
+ }
+
+ this.sendChromeMessage(options);
+};
+RilObject.prototype[REQUEST_REPORT_SMS_MEMORY_STATUS] = function REQUEST_REPORT_SMS_MEMORY_STATUS(length, options) {
+ this.pendingToReportSmsMemoryStatus = !!options.errorMsg;
+};
+RilObject.prototype[REQUEST_REPORT_STK_SERVICE_IS_RUNNING] = null;
+RilObject.prototype[REQUEST_CDMA_GET_SUBSCRIPTION_SOURCE] = null;
+RilObject.prototype[REQUEST_ISIM_AUTHENTICATION] = null;
+RilObject.prototype[REQUEST_ACKNOWLEDGE_INCOMING_GSM_SMS_WITH_PDU] = null;
+RilObject.prototype[REQUEST_STK_SEND_ENVELOPE_WITH_STATUS] = function REQUEST_STK_SEND_ENVELOPE_WITH_STATUS(length, options) {
+ if (options.errorMsg) {
+ this.acknowledgeGsmSms(false, PDU_FCS_UNSPECIFIED);
+ return;
+ }
+
+ let Buf = this.context.Buf;
+ let sw1 = Buf.readInt32();
+ let sw2 = Buf.readInt32();
+ if ((sw1 == ICC_STATUS_SAT_BUSY) && (sw2 === 0x00)) {
+ this.acknowledgeGsmSms(false, PDU_FCS_USAT_BUSY);
+ return;
+ }
+
+ let success = ((sw1 == ICC_STATUS_NORMAL_ENDING) && (sw2 === 0x00))
+ || (sw1 == ICC_STATUS_NORMAL_ENDING_WITH_EXTRA);
+
+ let messageStringLength = Buf.readInt32(); // In semi-octets
+ let responsePduLen = messageStringLength / 2; // In octets
+ if (!responsePduLen) {
+ this.acknowledgeGsmSms(success, success ? PDU_FCS_OK
+ : PDU_FCS_USIM_DATA_DOWNLOAD_ERROR);
+ return;
+ }
+
+ this.acknowledgeIncomingGsmSmsWithPDU(success, responsePduLen, options);
+};
+RilObject.prototype[REQUEST_VOICE_RADIO_TECH] = function REQUEST_VOICE_RADIO_TECH(length, options) {
+ if (options.errorMsg) {
+ if (DEBUG) {
+ this.context.debug("Error when getting voice radio tech: " +
+ options.errorMsg);
+ }
+ return;
+ }
+ let radioTech = this.context.Buf.readInt32List();
+ this._processRadioTech(radioTech[0]);
+};
+RilObject.prototype[REQUEST_SET_UNSOL_CELL_INFO_LIST_RATE] = null;
+RilObject.prototype[REQUEST_SET_INITIAL_ATTACH_APN] = null;
+RilObject.prototype[REQUEST_IMS_REGISTRATION_STATE] = null;
+RilObject.prototype[REQUEST_IMS_SEND_SMS] = null;
+RilObject.prototype[REQUEST_SIM_TRANSMIT_APDU_BASIC] = null;
+RilObject.prototype[REQUEST_SIM_OPEN_CHANNEL] = function REQUEST_SIM_OPEN_CHANNEL(length, options) {
+ if (options.errorMsg) {
+ this.sendChromeMessage(options);
+ return;
+ }
+
+ options.channel = this.context.Buf.readInt32List()[0];
+ // onwards may optionally contain the select response for the open channel
+ // command with one byte per integer.
+ this.sendChromeMessage(options);
+};
+RilObject.prototype[REQUEST_SIM_CLOSE_CHANNEL] = function REQUEST_SIM_CLOSE_CHANNEL(length, options) {
+ this.sendDefaultResponse(options);
+};
+RilObject.prototype[REQUEST_SIM_TRANSMIT_APDU_CHANNEL] = function REQUEST_SIM_TRANSMIT_APDU_CHANNEL(length, options) {
+ if (options.errorMsg) {
+ this.sendChromeMessage(options);
+ return;
+ }
+
+ let Buf = this.context.Buf;
+ options.sw1 = Buf.readInt32();
+ options.sw2 = Buf.readInt32();
+ options.simResponse = Buf.readString();
+ if (DEBUG) {
+ this.context.debug("Setting return values for RIL[REQUEST_SIM_TRANSMIT_APDU_CHANNEL]: [" +
+ options.sw1 + "," +
+ options.sw2 + ", " +
+ options.simResponse + "]");
+ }
+ this.sendChromeMessage(options);
+};
+RilObject.prototype[REQUEST_NV_READ_ITEM] = null;
+RilObject.prototype[REQUEST_NV_WRITE_ITEM] = null;
+RilObject.prototype[REQUEST_NV_WRITE_CDMA_PRL] = null;
+RilObject.prototype[REQUEST_NV_RESET_CONFIG] = null;
+RilObject.prototype[REQUEST_SET_UICC_SUBSCRIPTION] = function REQUEST_SET_UICC_SUBSCRIPTION(length, options) {
+ // Resend data subscription after uicc subscription.
+ if (this._attachDataRegistration) {
+ this.setDataRegistration({attach: true});
+ }
+};
+RilObject.prototype[REQUEST_ALLOW_DATA] = null;
+RilObject.prototype[REQUEST_GET_HARDWARE_CONFIG] = null;
+RilObject.prototype[REQUEST_SIM_AUTHENTICATION] = null;
+RilObject.prototype[REQUEST_GET_DC_RT_INFO] = null;
+RilObject.prototype[REQUEST_SET_DC_RT_INFO_RATE] = null;
+RilObject.prototype[REQUEST_SET_DATA_PROFILE] = null;
+RilObject.prototype[REQUEST_SHUTDOWN] = null;
+RilObject.prototype[REQUEST_SET_DATA_SUBSCRIPTION] = function REQUEST_SET_DATA_SUBSCRIPTION(length, options) {
+ if (!options.rilMessageType) {
+ // The request was made by ril_worker itself. Don't report.
+ return;
+ }
+ this.sendChromeMessage(options);
+};
+RilObject.prototype[REQUEST_GET_UNLOCK_RETRY_COUNT] = function REQUEST_GET_UNLOCK_RETRY_COUNT(length, options) {
+ options.retryCount = length ? this.context.Buf.readInt32List()[0] : -1;
+ this.sendChromeMessage(options);
+};
+RilObject.prototype[RIL_REQUEST_GPRS_ATTACH] = function RIL_REQUEST_GPRS_ATTACH(length, options) {
+ if (!options.rilMessageType) {
+ // The request was made by ril_worker itself. Don't report.
+ return;
+ }
+ this.sendChromeMessage(options);
+};
+RilObject.prototype[RIL_REQUEST_GPRS_DETACH] = function RIL_REQUEST_GPRS_DETACH(length, options) {
+ this.sendChromeMessage(options);
+};
+RilObject.prototype[UNSOLICITED_RESPONSE_RADIO_STATE_CHANGED] = function UNSOLICITED_RESPONSE_RADIO_STATE_CHANGED() {
+ let radioState = this.context.Buf.readInt32();
+ let newState;
+ switch (radioState) {
+ case RADIO_STATE_UNAVAILABLE:
+ newState = GECKO_RADIOSTATE_UNKNOWN;
+ break;
+ case RADIO_STATE_OFF:
+ newState = GECKO_RADIOSTATE_DISABLED;
+ break;
+ default:
+ newState = GECKO_RADIOSTATE_ENABLED;
+ }
+
+ if (DEBUG) {
+ this.context.debug("Radio state changed from '" + this.radioState +
+ "' to '" + newState + "'");
+ }
+ if (this.radioState == newState) {
+ return;
+ }
+
+ if (radioState !== RADIO_STATE_UNAVAILABLE) {
+ // Retrieve device identities once radio is available.
+ this.getDeviceIdentity();
+ }
+
+ if (radioState == RADIO_STATE_ON) {
+ // This value is defined in RIL v7, we will retrieve radio tech by another
+ // request. We leave _isCdma untouched, and it will be set once we get the
+ // radio technology.
+ this._waitingRadioTech = true;
+ this.getVoiceRadioTechnology();
+ }
+
+ if ((this.radioState == GECKO_RADIOSTATE_UNKNOWN ||
+ this.radioState == GECKO_RADIOSTATE_DISABLED) &&
+ newState == GECKO_RADIOSTATE_ENABLED) {
+ // The radio became available, let's get its info.
+ this.getBasebandVersion();
+ this.updateCellBroadcastConfig();
+ if ((RILQUIRKS_DATA_REGISTRATION_ON_DEMAND ||
+ RILQUIRKS_SUBSCRIPTION_CONTROL) &&
+ this._attachDataRegistration) {
+ this.setDataRegistration({attach: true});
+ }
+
+ if (this.pendingToReportSmsMemoryStatus) {
+ this._updateSmsMemoryStatus();
+ }
+ }
+
+ this.radioState = newState;
+ this.sendChromeMessage({
+ rilMessageType: "radiostatechange",
+ radioState: newState
+ });
+
+ // If the radio is up and on, so let's query the card state.
+ // On older RILs only if the card is actually ready, though.
+ // If _waitingRadioTech is set, we don't need to get icc status now.
+ if (radioState == RADIO_STATE_UNAVAILABLE ||
+ radioState == RADIO_STATE_OFF ||
+ this._waitingRadioTech) {
+ return;
+ }
+ this.getICCStatus();
+};
+RilObject.prototype[UNSOLICITED_RESPONSE_CALL_STATE_CHANGED] = function UNSOLICITED_RESPONSE_CALL_STATE_CHANGED() {
+ this.getCurrentCalls();
+};
+RilObject.prototype[UNSOLICITED_RESPONSE_VOICE_NETWORK_STATE_CHANGED] = function UNSOLICITED_RESPONSE_VOICE_NETWORK_STATE_CHANGED() {
+ if (DEBUG) {
+ this.context.debug("Network state changed, re-requesting phone state and " +
+ "ICC status");
+ }
+ this.getICCStatus();
+ this.requestNetworkInfo();
+};
+RilObject.prototype[UNSOLICITED_RESPONSE_NEW_SMS] = function UNSOLICITED_RESPONSE_NEW_SMS(length) {
+ let [message, result] = this.context.GsmPDUHelper.processReceivedSms(length);
+
+ if (message) {
+ result = this._processSmsMultipart(message);
+ }
+
+ if (result == PDU_FCS_RESERVED || result == MOZ_FCS_WAIT_FOR_EXPLICIT_ACK) {
+ return;
+ }
+
+ // Not reserved FCS values, send ACK now.
+ this.acknowledgeGsmSms(result == PDU_FCS_OK, result);
+};
+RilObject.prototype[UNSOLICITED_RESPONSE_NEW_SMS_STATUS_REPORT] = function UNSOLICITED_RESPONSE_NEW_SMS_STATUS_REPORT(length) {
+ let result = this._processSmsStatusReport(length);
+ this.acknowledgeGsmSms(result == PDU_FCS_OK, result);
+};
+RilObject.prototype[UNSOLICITED_RESPONSE_NEW_SMS_ON_SIM] = function UNSOLICITED_RESPONSE_NEW_SMS_ON_SIM(length) {
+ let recordNumber = this.context.Buf.readInt32List()[0];
+
+ this.context.SimRecordHelper.readSMS(
+ recordNumber,
+ function onsuccess(message) {
+ if (message && message.simStatus === 3) { //New Unread SMS
+ this._processSmsMultipart(message);
+ }
+ }.bind(this),
+ function onerror(errorMsg) {
+ if (DEBUG) {
+ this.context.debug("Failed to Read NEW SMS on SIM #" + recordNumber +
+ ", errorMsg: " + errorMsg);
+ }
+ });
+};
+RilObject.prototype[UNSOLICITED_ON_USSD] = function UNSOLICITED_ON_USSD() {
+ let [typeCode, message] = this.context.Buf.readStringList();
+ if (DEBUG) {
+ this.context.debug("On USSD. Type Code: " + typeCode + " Message: " + message);
+ }
+
+ this.sendChromeMessage({rilMessageType: "ussdreceived",
+ message: message,
+ // Per ril.h the USSD session is assumed to persist if
+ // the type code is "1", otherwise the current session
+ // (if any) is assumed to have terminated.
+ sessionEnded: typeCode !== "1"});
+};
+RilObject.prototype[UNSOLICITED_ON_USSD_REQUEST] = null;
+RilObject.prototype[UNSOLICITED_NITZ_TIME_RECEIVED] = function UNSOLICITED_NITZ_TIME_RECEIVED() {
+ let dateString = this.context.Buf.readString();
+
+ // The data contained in the NITZ message is
+ // in the form "yy/mm/dd,hh:mm:ss(+/-)tz,dt"
+ // for example: 12/02/16,03:36:08-20,00,310410
+ // See also bug 714352 - Listen for NITZ updates from rild.
+
+ if (DEBUG) this.context.debug("DateTimeZone string " + dateString);
+
+ let now = Date.now();
+
+ let year = parseInt(dateString.substr(0, 2), 10);
+ let month = parseInt(dateString.substr(3, 2), 10);
+ let day = parseInt(dateString.substr(6, 2), 10);
+ let hours = parseInt(dateString.substr(9, 2), 10);
+ let minutes = parseInt(dateString.substr(12, 2), 10);
+ let seconds = parseInt(dateString.substr(15, 2), 10);
+ // Note that |tz| is in 15-min units.
+ let tz = parseInt(dateString.substr(17, 3), 10);
+ // Note that |dst| is in 1-hour units and is already applied in |tz|.
+ let dst = parseInt(dateString.substr(21, 2), 10);
+
+ let timeInMS = Date.UTC(year + PDU_TIMESTAMP_YEAR_OFFSET, month - 1, day,
+ hours, minutes, seconds);
+
+ if (isNaN(timeInMS)) {
+ if (DEBUG) this.context.debug("NITZ failed to convert date");
+ return;
+ }
+
+ this.sendChromeMessage({rilMessageType: "nitzTime",
+ networkTimeInMS: timeInMS,
+ networkTimeZoneInMinutes: -(tz * 15),
+ networkDSTInMinutes: -(dst * 60),
+ receiveTimeInMS: now});
+};
+
+RilObject.prototype[UNSOLICITED_SIGNAL_STRENGTH] = function UNSOLICITED_SIGNAL_STRENGTH(length) {
+ this[REQUEST_SIGNAL_STRENGTH](length, {});
+};
+RilObject.prototype[UNSOLICITED_DATA_CALL_LIST_CHANGED] = function UNSOLICITED_DATA_CALL_LIST_CHANGED(length) {
+ this[REQUEST_DATA_CALL_LIST](length, {});
+};
+RilObject.prototype[UNSOLICITED_SUPP_SVC_NOTIFICATION] = function UNSOLICITED_SUPP_SVC_NOTIFICATION(length) {
+ let Buf = this.context.Buf;
+ let info = {};
+ info.notificationType = Buf.readInt32();
+ info.code = Buf.readInt32();
+ info.index = Buf.readInt32();
+ info.type = Buf.readInt32();
+ info.number = Buf.readString();
+
+ this._processSuppSvcNotification(info);
+};
+
+RilObject.prototype[UNSOLICITED_STK_SESSION_END] = function UNSOLICITED_STK_SESSION_END() {
+ this.sendChromeMessage({rilMessageType: "stksessionend"});
+};
+RilObject.prototype[UNSOLICITED_STK_PROACTIVE_COMMAND] = function UNSOLICITED_STK_PROACTIVE_COMMAND() {
+ this.processStkProactiveCommand();
+};
+RilObject.prototype[UNSOLICITED_STK_EVENT_NOTIFY] = function UNSOLICITED_STK_EVENT_NOTIFY() {
+ this.processStkProactiveCommand();
+};
+RilObject.prototype[UNSOLICITED_STK_CALL_SETUP] = null;
+RilObject.prototype[UNSOLICITED_SIM_SMS_STORAGE_FULL] = null;
+RilObject.prototype[UNSOLICITED_SIM_REFRESH] = null;
+RilObject.prototype[UNSOLICITED_CALL_RING] = function UNSOLICITED_CALL_RING() {
+ let Buf = this.context.Buf;
+ let info = {rilMessageType: "callRing"};
+ let isCDMA = false; //XXX TODO hard-code this for now
+ if (isCDMA) {
+ info.isPresent = Buf.readInt32();
+ info.signalType = Buf.readInt32();
+ info.alertPitch = Buf.readInt32();
+ info.signal = Buf.readInt32();
+ }
+ // At this point we don't know much other than the fact there's an incoming
+ // call, but that's enough to bring up the Phone app already. We'll know
+ // details once we get a call state changed notification and can then
+ // dispatch DOM events etc.
+ this.sendChromeMessage(info);
+};
+RilObject.prototype[UNSOLICITED_RESPONSE_SIM_STATUS_CHANGED] = function UNSOLICITED_RESPONSE_SIM_STATUS_CHANGED() {
+ this.getICCStatus();
+};
+RilObject.prototype[UNSOLICITED_RESPONSE_CDMA_NEW_SMS] = function UNSOLICITED_RESPONSE_CDMA_NEW_SMS(length) {
+ let [message, result] = this.context.CdmaPDUHelper.processReceivedSms(length);
+
+ if (message) {
+ if (message.teleservice === PDU_CDMA_MSG_TELESERIVCIE_ID_WAP) {
+ result = this._processCdmaSmsWapPush(message);
+ } else if (message.subMsgType === PDU_CDMA_MSG_TYPE_DELIVER_ACK) {
+ result = this._processCdmaSmsStatusReport(message);
+ } else {
+ result = this._processSmsMultipart(message);
+ }
+ }
+
+ if (result == PDU_FCS_RESERVED || result == MOZ_FCS_WAIT_FOR_EXPLICIT_ACK) {
+ return;
+ }
+
+ // Not reserved FCS values, send ACK now.
+ this.acknowledgeCdmaSms(result == PDU_FCS_OK, result);
+};
+RilObject.prototype[UNSOLICITED_RESPONSE_NEW_BROADCAST_SMS] = function UNSOLICITED_RESPONSE_NEW_BROADCAST_SMS(length) {
+ let message;
+ try {
+ message =
+ this.context.GsmPDUHelper.readCbMessage(this.context.Buf.readInt32());
+
+ // "Data-Download" message is expected to be handled by the modem.
+ // Ignore it here to prevent any garbage messages to be displayed.
+ // See 9.4.1.2.2 Message Identifier of TS 32.041 for the range of
+ // Message-identifier of the Data-Download CB messages.
+ if (message.messageId >= 0x1000 && message.messageId <= 0x10FF) {
+ if (DEBUG) {
+ this.context.debug("Ignore a Data-Download message, messageId: " +
+ message.messageId);
+ }
+ return;
+ }
+ } catch (e) {
+ if (DEBUG) {
+ this.context.debug("Failed to parse Cell Broadcast message: " + e);
+ }
+ return;
+ }
+
+ message = this._processReceivedSmsCbPage(message);
+ if (!message) {
+ return;
+ }
+
+ // Bug 1235697, failed to deactivate CBS in some modem.
+ // Workaround it according to the settings.
+ // Note: ETWS/CMAS/PWS can be received even disabled.
+ // It will be displayed according to the setting in application layer.
+ if (this.cellBroadcastDisabled && (
+ !(message.messageId >= 0x1100 && message.messageId <= 0x1107) && // ETWS
+ !(message.messageId >= 0x1112 && message.messageId <= 0x112F) && // CMAS
+ !(message.messageId >= 0x1130 && message.messageId <= 0x18FF) // PWS
+ )) {
+ if (DEBUG) {
+ this.context.debug("Ignore a CB message when disabled, messageId: " +
+ message.messageId);
+ }
+ return;
+ }
+
+ message.rilMessageType = "cellbroadcast-received";
+ this.sendChromeMessage(message);
+};
+RilObject.prototype[UNSOLICITED_CDMA_RUIM_SMS_STORAGE_FULL] = null;
+RilObject.prototype[UNSOLICITED_RESTRICTED_STATE_CHANGED] = null;
+RilObject.prototype[UNSOLICITED_ENTER_EMERGENCY_CALLBACK_MODE] = function UNSOLICITED_ENTER_EMERGENCY_CALLBACK_MODE() {
+ this._handleChangedEmergencyCbMode(true);
+};
+RilObject.prototype[UNSOLICITED_CDMA_CALL_WAITING] = function UNSOLICITED_CDMA_CALL_WAITING(length) {
+ let Buf = this.context.Buf;
+ let call = {};
+ call.number = Buf.readString();
+ call.numberPresentation = Buf.readInt32();
+ call.name = Buf.readString();
+ call.namePresentation = Buf.readInt32();
+ call.isPresent = Buf.readInt32();
+ call.signalType = Buf.readInt32();
+ call.alertPitch = Buf.readInt32();
+ call.signal = Buf.readInt32();
+ this.sendChromeMessage({rilMessageType: "cdmaCallWaiting",
+ waitingCall: call});
+};
+RilObject.prototype[UNSOLICITED_CDMA_OTA_PROVISION_STATUS] = function UNSOLICITED_CDMA_OTA_PROVISION_STATUS() {
+ let status =
+ CDMA_OTA_PROVISION_STATUS_TO_GECKO[this.context.Buf.readInt32List()[0]];
+ if (!status) {
+ return;
+ }
+ this.sendChromeMessage({rilMessageType: "otastatuschange",
+ status: status});
+};
+RilObject.prototype[UNSOLICITED_CDMA_INFO_REC] = function UNSOLICITED_CDMA_INFO_REC(length) {
+ this.sendChromeMessage({
+ rilMessageType: "cdma-info-rec-received",
+ records: this.context.CdmaPDUHelper.decodeInformationRecord()
+ });
+};
+RilObject.prototype[UNSOLICITED_OEM_HOOK_RAW] = null;
+RilObject.prototype[UNSOLICITED_RINGBACK_TONE] = null;
+RilObject.prototype[UNSOLICITED_RESEND_INCALL_MUTE] = null;
+RilObject.prototype[UNSOLICITED_CDMA_SUBSCRIPTION_SOURCE_CHANGED] = null;
+RilObject.prototype[UNSOLICITED_CDMA_PRL_CHANGED] = function UNSOLICITED_CDMA_PRL_CHANGED(length) {
+ let version = this.context.Buf.readInt32List()[0];
+ if (version !== this.iccInfo.prlVersion) {
+ this.iccInfo.prlVersion = version;
+ this.context.ICCUtilsHelper.handleICCInfoChange();
+ }
+};
+RilObject.prototype[UNSOLICITED_EXIT_EMERGENCY_CALLBACK_MODE] = function UNSOLICITED_EXIT_EMERGENCY_CALLBACK_MODE() {
+ this._handleChangedEmergencyCbMode(false);
+};
+RilObject.prototype[UNSOLICITED_RIL_CONNECTED] = function UNSOLICITED_RIL_CONNECTED(length) {
+ // Prevent response id collision between UNSOLICITED_RIL_CONNECTED and
+ // UNSOLICITED_VOICE_RADIO_TECH_CHANGED for Akami on gingerbread branch.
+ if (!length) {
+ return;
+ }
+
+ this.version = this.context.Buf.readInt32List()[0];
+ if (DEBUG) {
+ this.context.debug("Detected RIL version " + this.version);
+ }
+
+ this.initRILState();
+ // rild might have restarted, ensure data call list.
+ this.getDataCallList();
+ // Always ensure that we are not in emergency callback mode when init.
+ this.exitEmergencyCbMode();
+ // Reset radio in the case that b2g restart (or crash).
+ this.setRadioEnabled({enabled: false});
+};
+RilObject.prototype[UNSOLICITED_VOICE_RADIO_TECH_CHANGED] = function UNSOLICITED_VOICE_RADIO_TECH_CHANGED(length) {
+ // This unsolicited response will be sent when the technology of a multi-tech
+ // modem is changed, ex. switch between gsm and cdma.
+ // TODO: We may need to do more on updating data when switching between gsm
+ // and cdma mode, e.g. IMEI, ESN, iccInfo, iccType ... etc.
+ // See Bug 866038.
+ this._processRadioTech(this.context.Buf.readInt32List()[0]);
+};
+RilObject.prototype[UNSOLICITED_CELL_INFO_LIST] = null;
+RilObject.prototype[UNSOLICITED_RESPONSE_IMS_NETWORK_STATE_CHANGED] = null;
+RilObject.prototype[UNSOLICITED_UICC_SUBSCRIPTION_STATUS_CHANGED] = null;
+RilObject.prototype[UNSOLICITED_SRVCC_STATE_NOTIFY] = null;
+RilObject.prototype[UNSOLICITED_HARDWARE_CONFIG_CHANGED] = null;
+RilObject.prototype[UNSOLICITED_DC_RT_INFO_CHANGED] = null;
+
+/**
+ * This object exposes the functionality to parse and serialize PDU strings
+ *
+ * A PDU is a string containing a series of hexadecimally encoded octets
+ * or nibble-swapped binary-coded decimals (BCDs). It contains not only the
+ * message text but information about the sender, the SMS service center,
+ * timestamp, etc.
+ */
+function GsmPDUHelperObject(aContext) {
+ this.context = aContext;
+}
+GsmPDUHelperObject.prototype = {
+ context: null,
+
+ /**
+ * Read one character (2 bytes) from a RIL string and decode as hex.
+ *
+ * @return the nibble as a number.
+ */
+ readHexNibble: function() {
+ let nibble = this.context.Buf.readUint16();
+ if (nibble >= 48 && nibble <= 57) {
+ nibble -= 48; // ASCII '0'..'9'
+ } else if (nibble >= 65 && nibble <= 70) {
+ nibble -= 55; // ASCII 'A'..'F'
+ } else if (nibble >= 97 && nibble <= 102) {
+ nibble -= 87; // ASCII 'a'..'f'
+ } else {
+ throw "Found invalid nibble during PDU parsing: " +
+ String.fromCharCode(nibble);
+ }
+ return nibble;
+ },
+
+ /**
+ * Encode a nibble as one hex character in a RIL string (2 bytes).
+ *
+ * @param nibble
+ * The nibble to encode (represented as a number)
+ */
+ writeHexNibble: function(nibble) {
+ nibble &= 0x0f;
+ if (nibble < 10) {
+ nibble += 48; // ASCII '0'
+ } else {
+ nibble += 55; // ASCII 'A'
+ }
+ this.context.Buf.writeUint16(nibble);
+ },
+
+ /**
+ * Read a hex-encoded octet (two nibbles).
+ *
+ * @return the octet as a number.
+ */
+ readHexOctet: function() {
+ return (this.readHexNibble() << 4) | this.readHexNibble();
+ },
+
+ /**
+ * Write an octet as two hex-encoded nibbles.
+ *
+ * @param octet
+ * The octet (represented as a number) to encode.
+ */
+ writeHexOctet: function(octet) {
+ this.writeHexNibble(octet >> 4);
+ this.writeHexNibble(octet);
+ },
+
+ /**
+ * Read an array of hex-encoded octets.
+ */
+ readHexOctetArray: function(length) {
+ let array = new Uint8Array(length);
+ for (let i = 0; i < length; i++) {
+ array[i] = this.readHexOctet();
+ }
+ return array;
+ },
+
+ /**
+ * Helper to write data into a temporary buffer for easier length encoding when
+ * the number of octets for the length encoding is varied.
+ *
+ * @param writeFunction
+ * Function of how the data to be written into temporary buffer.
+ *
+ * @return array of written octets.
+ **/
+ writeWithBuffer: function(writeFunction) {
+ let buf = [];
+ let writeHexOctet = this.writeHexOctet;
+ this.writeHexOctet = function(octet) {
+ buf.push(octet);
+ }
+
+ try {
+ writeFunction();
+ } catch (e) {
+ if (DEBUG) {
+ debug("Error when writeWithBuffer: " + e);
+ }
+ buf = [];
+ } finally {
+ this.writeHexOctet = writeHexOctet;
+ }
+
+ return buf;
+ },
+
+ /**
+ * Convert an octet (number) to a BCD number.
+ *
+ * Any nibbles that are not in the BCD range count as 0.
+ *
+ * @param octet
+ * The octet (a number, as returned by getOctet())
+ *
+ * @return the corresponding BCD number.
+ */
+ octetToBCD: function(octet) {
+ return ((octet & 0xf0) <= 0x90) * ((octet >> 4) & 0x0f) +
+ ((octet & 0x0f) <= 0x09) * (octet & 0x0f) * 10;
+ },
+
+ /**
+ * Convert a BCD number to an octet (number)
+ *
+ * Only take two digits with absolute value.
+ *
+ * @param bcd
+ *
+ * @return the corresponding octet.
+ */
+ BCDToOctet: function(bcd) {
+ bcd = Math.abs(bcd);
+ return ((bcd % 10) << 4) + (Math.floor(bcd / 10) % 10);
+ },
+
+ /**
+ * Convert a semi-octet (number) to a GSM BCD char, or return empty
+ * string if invalid semiOctet and suppressException is set to true.
+ *
+ * @param semiOctet
+ * Nibble to be converted to.
+ * @param suppressException [optional]
+ * Suppress exception if invalid semiOctet and suppressException is set
+ * to true.
+ *
+ * @return GSM BCD char, or empty string.
+ */
+ bcdChars: "0123456789",
+ semiOctetToBcdChar: function(semiOctet, suppressException) {
+ if (semiOctet >= this.bcdChars.length) {
+ if (suppressException) {
+ return "";
+ } else {
+ throw new RangeError();
+ }
+ }
+
+ return this.bcdChars.charAt(semiOctet);
+ },
+
+ /**
+ * Convert a semi-octet (number) to a GSM extended BCD char, or return empty
+ * string if invalid semiOctet and suppressException is set to true.
+ *
+ * @param semiOctet
+ * Nibble to be converted to.
+ * @param suppressException [optional]
+ * Suppress exception if invalid semiOctet and suppressException is set
+ * to true.
+ *
+ * @return GSM extended BCD char, or empty string.
+ */
+ extendedBcdChars: "0123456789*#,;",
+ semiOctetToExtendedBcdChar: function(semiOctet, suppressException) {
+ if (semiOctet >= this.extendedBcdChars.length) {
+ if (suppressException) {
+ return "";
+ } else {
+ throw new RangeError();
+ }
+ }
+
+ return this.extendedBcdChars.charAt(semiOctet);
+ },
+
+ /**
+ * Convert string to a GSM extended BCD string
+ */
+ stringToExtendedBcd: function(string) {
+ return string.replace(/[^0-9*#,]/g, "")
+ .replace(/\*/g, "a")
+ .replace(/\#/g, "b")
+ .replace(/\,/g, "c");
+ },
+
+ /**
+ * Read a *swapped nibble* binary coded decimal (BCD)
+ *
+ * @param pairs
+ * Number of nibble *pairs* to read.
+ *
+ * @return the decimal as a number.
+ */
+ readSwappedNibbleBcdNum: function(pairs) {
+ let number = 0;
+ for (let i = 0; i < pairs; i++) {
+ let octet = this.readHexOctet();
+ // Ignore 'ff' octets as they're often used as filler.
+ if (octet == 0xff) {
+ continue;
+ }
+ // If the first nibble is an "F" , only the second nibble is to be taken
+ // into account.
+ if ((octet & 0xf0) == 0xf0) {
+ number *= 10;
+ number += octet & 0x0f;
+ continue;
+ }
+ number *= 100;
+ number += this.octetToBCD(octet);
+ }
+ return number;
+ },
+
+ /**
+ * Read a *swapped nibble* binary coded decimal (BCD) string
+ *
+ * @param pairs
+ * Number of nibble *pairs* to read.
+ * @param suppressException [optional]
+ * Suppress exception if invalid semiOctet and suppressException is set
+ * to true.
+ *
+ * @return The BCD string.
+ */
+ readSwappedNibbleBcdString: function(pairs, suppressException) {
+ let str = "";
+ for (let i = 0; i < pairs; i++) {
+ let nibbleH = this.readHexNibble();
+ let nibbleL = this.readHexNibble();
+ if (nibbleL == 0x0F) {
+ break;
+ }
+
+ str += this.semiOctetToBcdChar(nibbleL, suppressException);
+ if (nibbleH != 0x0F) {
+ str += this.semiOctetToBcdChar(nibbleH, suppressException);
+ }
+ }
+
+ return str;
+ },
+
+ /**
+ * Read a *swapped nibble* extended binary coded decimal (BCD) string
+ *
+ * @param pairs
+ * Number of nibble *pairs* to read.
+ * @param suppressException [optional]
+ * Suppress exception if invalid semiOctet and suppressException is set
+ * to true.
+ *
+ * @return The BCD string.
+ */
+ readSwappedNibbleExtendedBcdString: function(pairs, suppressException) {
+ let str = "";
+ for (let i = 0; i < pairs; i++) {
+ let nibbleH = this.readHexNibble();
+ let nibbleL = this.readHexNibble();
+ if (nibbleL == 0x0F) {
+ break;
+ }
+
+ str += this.semiOctetToExtendedBcdChar(nibbleL, suppressException);
+ if (nibbleH != 0x0F) {
+ str += this.semiOctetToExtendedBcdChar(nibbleH, suppressException);
+ }
+ }
+
+ return str;
+ },
+
+ /**
+ * Write numerical data as swapped nibble BCD.
+ *
+ * @param data
+ * Data to write (as a string or a number)
+ */
+ writeSwappedNibbleBCD: function(data) {
+ data = data.toString();
+ if (data.length % 2) {
+ data += "F";
+ }
+ let Buf = this.context.Buf;
+ for (let i = 0; i < data.length; i += 2) {
+ Buf.writeUint16(data.charCodeAt(i + 1));
+ Buf.writeUint16(data.charCodeAt(i));
+ }
+ },
+
+ /**
+ * Write numerical data as swapped nibble BCD.
+ * If the number of digit of data is even, add '0' at the beginning.
+ *
+ * @param data
+ * Data to write (as a string or a number)
+ */
+ writeSwappedNibbleBCDNum: function(data) {
+ data = data.toString();
+ if (data.length % 2) {
+ data = "0" + data;
+ }
+ let Buf = this.context.Buf;
+ for (let i = 0; i < data.length; i += 2) {
+ Buf.writeUint16(data.charCodeAt(i + 1));
+ Buf.writeUint16(data.charCodeAt(i));
+ }
+ },
+
+ /**
+ * Read user data, convert to septets, look up relevant characters in a
+ * 7-bit alphabet, and construct string.
+ *
+ * @param length
+ * Number of septets to read (*not* octets)
+ * @param paddingBits
+ * Number of padding bits in the first byte of user data.
+ * @param langIndex
+ * Table index used for normal 7-bit encoded character lookup.
+ * @param langShiftIndex
+ * Table index used for escaped 7-bit encoded character lookup.
+ *
+ * @return a string.
+ */
+ readSeptetsToString: function(length, paddingBits, langIndex, langShiftIndex) {
+ let ret = "";
+ let byteLength = Math.ceil((length * 7 + paddingBits) / 8);
+
+ /**
+ * |<- last byte in header ->|
+ * |<- incompleteBits ->|<- last header septet->|
+ * +===7===|===6===|===5===|===4===|===3===|===2===|===1===|===0===|
+ *
+ * |<- 1st byte in user data ->|
+ * |<- data septet 1 ->|<-paddingBits->|
+ * +===7===|===6===|===5===|===4===|===3===|===2===|===1===|===0===|
+ *
+ * |<- 2nd byte in user data ->|
+ * |<- data spetet 2 ->|<-ds1->|
+ * +===7===|===6===|===5===|===4===|===3===|===2===|===1===|===0===|
+ */
+ let data = 0;
+ let dataBits = 0;
+ if (paddingBits) {
+ data = this.readHexOctet() >> paddingBits;
+ dataBits = 8 - paddingBits;
+ --byteLength;
+ }
+
+ let escapeFound = false;
+ const langTable = PDU_NL_LOCKING_SHIFT_TABLES[langIndex];
+ const langShiftTable = PDU_NL_SINGLE_SHIFT_TABLES[langShiftIndex];
+ do {
+ // Read as much as fits in 32bit word
+ let bytesToRead = Math.min(byteLength, dataBits ? 3 : 4);
+ for (let i = 0; i < bytesToRead; i++) {
+ data |= this.readHexOctet() << dataBits;
+ dataBits += 8;
+ --byteLength;
+ }
+
+ // Consume available full septets
+ for (; dataBits >= 7; dataBits -= 7) {
+ let septet = data & 0x7F;
+ data >>>= 7;
+
+ if (escapeFound) {
+ escapeFound = false;
+ if (septet == PDU_NL_EXTENDED_ESCAPE) {
+ // According to 3GPP TS 23.038, section 6.2.1.1, NOTE 1, "On
+ // receipt of this code, a receiving entity shall display a space
+ // until another extensiion table is defined."
+ ret += " ";
+ } else if (septet == PDU_NL_RESERVED_CONTROL) {
+ // According to 3GPP TS 23.038 B.2, "This code represents a control
+ // character and therefore must not be used for language specific
+ // characters."
+ ret += " ";
+ } else {
+ ret += langShiftTable[septet];
+ }
+ } else if (septet == PDU_NL_EXTENDED_ESCAPE) {
+ escapeFound = true;
+
+ // <escape> is not an effective character
+ --length;
+ } else {
+ ret += langTable[septet];
+ }
+ }
+ } while (byteLength);
+
+ if (ret.length != length) {
+ /**
+ * If num of effective characters does not equal to the length of read
+ * string, cut the tail off. This happens when the last octet of user
+ * data has following layout:
+ *
+ * |<- penultimate octet in user data ->|
+ * |<- data septet N ->|<- dsN-1 ->|
+ * +===7===|===6===|===5===|===4===|===3===|===2===|===1===|===0===|
+ *
+ * |<- last octet in user data ->|
+ * |<- fill bits ->|<-dsN->|
+ * +===7===|===6===|===5===|===4===|===3===|===2===|===1===|===0===|
+ *
+ * The fill bits in the last octet may happen to form a full septet and
+ * be appended at the end of result string.
+ */
+ ret = ret.slice(0, length);
+ }
+ return ret;
+ },
+
+ writeStringAsSeptets: function(message, paddingBits, langIndex, langShiftIndex) {
+ const langTable = PDU_NL_LOCKING_SHIFT_TABLES[langIndex];
+ const langShiftTable = PDU_NL_SINGLE_SHIFT_TABLES[langShiftIndex];
+
+ let dataBits = paddingBits;
+ let data = 0;
+ for (let i = 0; i < message.length; i++) {
+ let c = message.charAt(i);
+ let septet = langTable.indexOf(c);
+ if (septet == PDU_NL_EXTENDED_ESCAPE) {
+ continue;
+ }
+
+ if (septet >= 0) {
+ data |= septet << dataBits;
+ dataBits += 7;
+ } else {
+ septet = langShiftTable.indexOf(c);
+ if (septet == -1) {
+ throw new Error("'" + c + "' is not in 7 bit alphabet "
+ + langIndex + ":" + langShiftIndex + "!");
+ }
+
+ if (septet == PDU_NL_RESERVED_CONTROL) {
+ continue;
+ }
+
+ data |= PDU_NL_EXTENDED_ESCAPE << dataBits;
+ dataBits += 7;
+ data |= septet << dataBits;
+ dataBits += 7;
+ }
+
+ for (; dataBits >= 8; dataBits -= 8) {
+ this.writeHexOctet(data & 0xFF);
+ data >>>= 8;
+ }
+ }
+
+ if (dataBits !== 0) {
+ this.writeHexOctet(data & 0xFF);
+ }
+ },
+
+ writeStringAs8BitUnpacked: function(text) {
+ const langTable = PDU_NL_LOCKING_SHIFT_TABLES[PDU_NL_IDENTIFIER_DEFAULT];
+ const langShiftTable = PDU_NL_SINGLE_SHIFT_TABLES[PDU_NL_IDENTIFIER_DEFAULT];
+
+ let len = text ? text.length : 0;
+ for (let i = 0; i < len; i++) {
+ let c = text.charAt(i);
+ let octet = langTable.indexOf(c);
+
+ if (octet == -1) {
+ octet = langShiftTable.indexOf(c);
+ if (octet == -1) {
+ // Fallback to ASCII space.
+ octet = langTable.indexOf(' ');
+ } else {
+ this.writeHexOctet(PDU_NL_EXTENDED_ESCAPE);
+ }
+ }
+ this.writeHexOctet(octet);
+ }
+ },
+
+ /**
+ * Read user data and decode as a UCS2 string.
+ *
+ * @param numOctets
+ * Number of octets to be read as UCS2 string.
+ *
+ * @return a string.
+ */
+ readUCS2String: function(numOctets) {
+ let str = "";
+ let length = numOctets / 2;
+ for (let i = 0; i < length; ++i) {
+ let code = (this.readHexOctet() << 8) | this.readHexOctet();
+ str += String.fromCharCode(code);
+ }
+
+ if (DEBUG) this.context.debug("Read UCS2 string: " + str);
+
+ return str;
+ },
+
+ /**
+ * Write user data as a UCS2 string.
+ *
+ * @param message
+ * Message string to encode as UCS2 in hex-encoded octets.
+ */
+ writeUCS2String: function(message) {
+ for (let i = 0; i < message.length; ++i) {
+ let code = message.charCodeAt(i);
+ this.writeHexOctet((code >> 8) & 0xFF);
+ this.writeHexOctet(code & 0xFF);
+ }
+ },
+
+ /**
+ * Read 1 + UDHL octets and construct user data header.
+ *
+ * @param msg
+ * message object for output.
+ *
+ * @see 3GPP TS 23.040 9.2.3.24
+ */
+ readUserDataHeader: function(msg) {
+ /**
+ * A header object with properties contained in received message.
+ * The properties set include:
+ *
+ * length: totoal length of the header, default 0.
+ * langIndex: used locking shift table index, default
+ * PDU_NL_IDENTIFIER_DEFAULT.
+ * langShiftIndex: used locking shift table index, default
+ * PDU_NL_IDENTIFIER_DEFAULT.
+ *
+ */
+ let header = {
+ length: 0,
+ langIndex: PDU_NL_IDENTIFIER_DEFAULT,
+ langShiftIndex: PDU_NL_IDENTIFIER_DEFAULT
+ };
+
+ header.length = this.readHexOctet();
+ if (DEBUG) this.context.debug("Read UDH length: " + header.length);
+
+ let dataAvailable = header.length;
+ while (dataAvailable >= 2) {
+ let id = this.readHexOctet();
+ let length = this.readHexOctet();
+ if (DEBUG) this.context.debug("Read UDH id: " + id + ", length: " + length);
+
+ dataAvailable -= 2;
+
+ switch (id) {
+ case PDU_IEI_CONCATENATED_SHORT_MESSAGES_8BIT: {
+ let ref = this.readHexOctet();
+ let max = this.readHexOctet();
+ let seq = this.readHexOctet();
+ dataAvailable -= 3;
+ if (max && seq && (seq <= max)) {
+ header.segmentRef = ref;
+ header.segmentMaxSeq = max;
+ header.segmentSeq = seq;
+ }
+ break;
+ }
+ case PDU_IEI_APPLICATION_PORT_ADDRESSING_SCHEME_8BIT: {
+ let dstp = this.readHexOctet();
+ let orip = this.readHexOctet();
+ dataAvailable -= 2;
+ if ((dstp < PDU_APA_RESERVED_8BIT_PORTS)
+ || (orip < PDU_APA_RESERVED_8BIT_PORTS)) {
+ // 3GPP TS 23.040 clause 9.2.3.24.3: "A receiving entity shall
+ // ignore any information element where the value of the
+ // Information-Element-Data is Reserved or not supported"
+ break;
+ }
+ header.destinationPort = dstp;
+ header.originatorPort = orip;
+ break;
+ }
+ case PDU_IEI_APPLICATION_PORT_ADDRESSING_SCHEME_16BIT: {
+ let dstp = (this.readHexOctet() << 8) | this.readHexOctet();
+ let orip = (this.readHexOctet() << 8) | this.readHexOctet();
+ dataAvailable -= 4;
+ if ((dstp >= PDU_APA_VALID_16BIT_PORTS) ||
+ (orip >= PDU_APA_VALID_16BIT_PORTS)) {
+ // 3GPP TS 23.040 clause 9.2.3.24.4: "A receiving entity shall
+ // ignore any information element where the value of the
+ // Information-Element-Data is Reserved or not supported"
+ // Bug 1130292, some carriers set originatorPort to reserved port
+ // numbers for wap push. We rise this as a warning in debug message
+ // instead of ingoring this IEI to allow user to receive Wap Push
+ // under these carriers.
+ this.context.debug("Warning: Invalid port numbers [dstp, orip]: " +
+ JSON.stringify([dstp, orip]));
+ }
+ header.destinationPort = dstp;
+ header.originatorPort = orip;
+ break;
+ }
+ case PDU_IEI_CONCATENATED_SHORT_MESSAGES_16BIT: {
+ let ref = (this.readHexOctet() << 8) | this.readHexOctet();
+ let max = this.readHexOctet();
+ let seq = this.readHexOctet();
+ dataAvailable -= 4;
+ if (max && seq && (seq <= max)) {
+ header.segmentRef = ref;
+ header.segmentMaxSeq = max;
+ header.segmentSeq = seq;
+ }
+ break;
+ }
+ case PDU_IEI_NATIONAL_LANGUAGE_SINGLE_SHIFT:
+ let langShiftIndex = this.readHexOctet();
+ --dataAvailable;
+ if (langShiftIndex < PDU_NL_SINGLE_SHIFT_TABLES.length) {
+ header.langShiftIndex = langShiftIndex;
+ }
+ break;
+ case PDU_IEI_NATIONAL_LANGUAGE_LOCKING_SHIFT:
+ let langIndex = this.readHexOctet();
+ --dataAvailable;
+ if (langIndex < PDU_NL_LOCKING_SHIFT_TABLES.length) {
+ header.langIndex = langIndex;
+ }
+ break;
+ case PDU_IEI_SPECIAL_SMS_MESSAGE_INDICATION:
+ let msgInd = this.readHexOctet() & 0xFF;
+ let msgCount = this.readHexOctet();
+ dataAvailable -= 2;
+
+
+ /*
+ * TS 23.040 V6.8.1 Sec 9.2.3.24.2
+ * bits 1 0 : basic message indication type
+ * bits 4 3 2 : extended message indication type
+ * bits 6 5 : Profile id
+ * bit 7 : storage type
+ */
+ let storeType = msgInd & PDU_MWI_STORE_TYPE_BIT;
+ let mwi = msg.mwi;
+ if (!mwi) {
+ mwi = msg.mwi = {};
+ }
+
+ if (storeType == PDU_MWI_STORE_TYPE_STORE) {
+ // Store message because TP_UDH indicates so, note this may override
+ // the setting in DCS, but that is expected
+ mwi.discard = false;
+ } else if (mwi.discard === undefined) {
+ // storeType == PDU_MWI_STORE_TYPE_DISCARD
+ // only override mwi.discard here if it hasn't already been set
+ mwi.discard = true;
+ }
+
+ mwi.msgCount = msgCount & 0xFF;
+ mwi.active = mwi.msgCount > 0;
+
+ if (DEBUG) {
+ this.context.debug("MWI in TP_UDH received: " + JSON.stringify(mwi));
+ }
+
+ break;
+ default:
+ if (DEBUG) {
+ this.context.debug("readUserDataHeader: unsupported IEI(" + id +
+ "), " + length + " bytes.");
+ }
+
+ // Read out unsupported data
+ if (length) {
+ let octets;
+ if (DEBUG) octets = new Uint8Array(length);
+
+ for (let i = 0; i < length; i++) {
+ let octet = this.readHexOctet();
+ if (DEBUG) octets[i] = octet;
+ }
+ dataAvailable -= length;
+
+ if (DEBUG) {
+ this.context.debug("readUserDataHeader: " + Array.slice(octets));
+ }
+ }
+ break;
+ }
+ }
+
+ if (dataAvailable !== 0) {
+ throw new Error("Illegal user data header found!");
+ }
+
+ msg.header = header;
+ },
+
+ /**
+ * Write out user data header.
+ *
+ * @param options
+ * Options containing information for user data header write-out. The
+ * `userDataHeaderLength` property must be correctly pre-calculated.
+ */
+ writeUserDataHeader: function(options) {
+ this.writeHexOctet(options.userDataHeaderLength);
+
+ if (options.segmentMaxSeq > 1) {
+ if (options.segmentRef16Bit) {
+ this.writeHexOctet(PDU_IEI_CONCATENATED_SHORT_MESSAGES_16BIT);
+ this.writeHexOctet(4);
+ this.writeHexOctet((options.segmentRef >> 8) & 0xFF);
+ } else {
+ this.writeHexOctet(PDU_IEI_CONCATENATED_SHORT_MESSAGES_8BIT);
+ this.writeHexOctet(3);
+ }
+ this.writeHexOctet(options.segmentRef & 0xFF);
+ this.writeHexOctet(options.segmentMaxSeq & 0xFF);
+ this.writeHexOctet(options.segmentSeq & 0xFF);
+ }
+
+ if (options.dcs == PDU_DCS_MSG_CODING_7BITS_ALPHABET) {
+ if (options.langIndex != PDU_NL_IDENTIFIER_DEFAULT) {
+ this.writeHexOctet(PDU_IEI_NATIONAL_LANGUAGE_LOCKING_SHIFT);
+ this.writeHexOctet(1);
+ this.writeHexOctet(options.langIndex);
+ }
+
+ if (options.langShiftIndex != PDU_NL_IDENTIFIER_DEFAULT) {
+ this.writeHexOctet(PDU_IEI_NATIONAL_LANGUAGE_SINGLE_SHIFT);
+ this.writeHexOctet(1);
+ this.writeHexOctet(options.langShiftIndex);
+ }
+ }
+ },
+
+ /**
+ * Read SM-TL Address.
+ *
+ * @param len
+ * Length of useful semi-octets within the Address-Value field. For
+ * example, the lenth of "12345" should be 5, and 4 for "1234".
+ *
+ * @see 3GPP TS 23.040 9.1.2.5
+ */
+ readAddress: function(len) {
+ // Address Length
+ if (!len || (len < 0)) {
+ if (DEBUG) {
+ this.context.debug("PDU error: invalid sender address length: " + len);
+ }
+ return null;
+ }
+ if (len % 2 == 1) {
+ len += 1;
+ }
+ if (DEBUG) this.context.debug("PDU: Going to read address: " + len);
+
+ // Type-of-Address
+ let toa = this.readHexOctet();
+ let addr = "";
+
+ if ((toa & 0xF0) == PDU_TOA_ALPHANUMERIC) {
+ addr = this.readSeptetsToString(Math.floor(len * 4 / 7), 0,
+ PDU_NL_IDENTIFIER_DEFAULT , PDU_NL_IDENTIFIER_DEFAULT );
+ return addr;
+ }
+ addr = this.readSwappedNibbleExtendedBcdString(len / 2);
+ if (addr.length <= 0) {
+ if (DEBUG) this.context.debug("PDU error: no number provided");
+ return null;
+ }
+ if ((toa & 0xF0) == (PDU_TOA_INTERNATIONAL)) {
+ addr = '+' + addr;
+ }
+
+ return addr;
+ },
+
+ /**
+ * Read TP-Protocol-Indicator(TP-PID).
+ *
+ * @param msg
+ * message object for output.
+ *
+ * @see 3GPP TS 23.040 9.2.3.9
+ */
+ readProtocolIndicator: function(msg) {
+ // `The MS shall interpret reserved, obsolete, or unsupported values as the
+ // value 00000000 but shall store them exactly as received.`
+ msg.pid = this.readHexOctet();
+
+ msg.epid = msg.pid;
+ switch (msg.epid & 0xC0) {
+ case 0x40:
+ // Bit 7..0 = 01xxxxxx
+ switch (msg.epid) {
+ case PDU_PID_SHORT_MESSAGE_TYPE_0:
+ case PDU_PID_ANSI_136_R_DATA:
+ case PDU_PID_USIM_DATA_DOWNLOAD:
+ return;
+ }
+ break;
+ }
+
+ msg.epid = PDU_PID_DEFAULT;
+ },
+
+ /**
+ * Read TP-Data-Coding-Scheme(TP-DCS)
+ *
+ * @param msg
+ * message object for output.
+ *
+ * @see 3GPP TS 23.040 9.2.3.10, 3GPP TS 23.038 4.
+ */
+ readDataCodingScheme: function(msg) {
+ let dcs = this.readHexOctet();
+ if (DEBUG) this.context.debug("PDU: read SMS dcs: " + dcs);
+
+ // No message class by default.
+ let messageClass = PDU_DCS_MSG_CLASS_NORMAL;
+ // 7 bit is the default fallback encoding.
+ let encoding = PDU_DCS_MSG_CODING_7BITS_ALPHABET;
+ switch (dcs & PDU_DCS_CODING_GROUP_BITS) {
+ case 0x40: // bits 7..4 = 01xx
+ case 0x50:
+ case 0x60:
+ case 0x70:
+ // Bit 5..0 are coded exactly the same as Group 00xx
+ case 0x00: // bits 7..4 = 00xx
+ case 0x10:
+ case 0x20:
+ case 0x30:
+ if (dcs & 0x10) {
+ messageClass = dcs & PDU_DCS_MSG_CLASS_BITS;
+ }
+ switch (dcs & 0x0C) {
+ case 0x4:
+ encoding = PDU_DCS_MSG_CODING_8BITS_ALPHABET;
+ break;
+ case 0x8:
+ encoding = PDU_DCS_MSG_CODING_16BITS_ALPHABET;
+ break;
+ }
+ break;
+
+ case 0xE0: // bits 7..4 = 1110
+ encoding = PDU_DCS_MSG_CODING_16BITS_ALPHABET;
+ // Bit 3..0 are coded exactly the same as Message Waiting Indication
+ // Group 1101.
+ // Fall through.
+ case 0xC0: // bits 7..4 = 1100
+ case 0xD0: // bits 7..4 = 1101
+ // Indiciates voicemail indicator set or clear
+ let active = (dcs & PDU_DCS_MWI_ACTIVE_BITS) == PDU_DCS_MWI_ACTIVE_VALUE;
+
+ // If TP-UDH is present, these values will be overwritten
+ switch (dcs & PDU_DCS_MWI_TYPE_BITS) {
+ case PDU_DCS_MWI_TYPE_VOICEMAIL:
+ let mwi = msg.mwi;
+ if (!mwi) {
+ mwi = msg.mwi = {};
+ }
+
+ mwi.active = active;
+ mwi.discard = (dcs & PDU_DCS_CODING_GROUP_BITS) == 0xC0;
+ mwi.msgCount = active ? GECKO_VOICEMAIL_MESSAGE_COUNT_UNKNOWN : 0;
+
+ if (DEBUG) {
+ this.context.debug("MWI in DCS received for voicemail: " +
+ JSON.stringify(mwi));
+ }
+ break;
+ case PDU_DCS_MWI_TYPE_FAX:
+ if (DEBUG) this.context.debug("MWI in DCS received for fax");
+ break;
+ case PDU_DCS_MWI_TYPE_EMAIL:
+ if (DEBUG) this.context.debug("MWI in DCS received for email");
+ break;
+ default:
+ if (DEBUG) this.context.debug("MWI in DCS received for \"other\"");
+ break;
+ }
+ break;
+
+ case 0xF0: // bits 7..4 = 1111
+ if (dcs & 0x04) {
+ encoding = PDU_DCS_MSG_CODING_8BITS_ALPHABET;
+ }
+ messageClass = dcs & PDU_DCS_MSG_CLASS_BITS;
+ break;
+
+ default:
+ // Falling back to default encoding.
+ break;
+ }
+
+ msg.dcs = dcs;
+ msg.encoding = encoding;
+ msg.messageClass = GECKO_SMS_MESSAGE_CLASSES[messageClass];
+
+ if (DEBUG) this.context.debug("PDU: message encoding is " + encoding + " bit.");
+ },
+
+ /**
+ * Read GSM TP-Service-Centre-Time-Stamp(TP-SCTS).
+ *
+ * @see 3GPP TS 23.040 9.2.3.11
+ */
+ readTimestamp: function() {
+ let year = this.readSwappedNibbleBcdNum(1) + PDU_TIMESTAMP_YEAR_OFFSET;
+ let month = this.readSwappedNibbleBcdNum(1) - 1;
+ let day = this.readSwappedNibbleBcdNum(1);
+ let hour = this.readSwappedNibbleBcdNum(1);
+ let minute = this.readSwappedNibbleBcdNum(1);
+ let second = this.readSwappedNibbleBcdNum(1);
+ let timestamp = Date.UTC(year, month, day, hour, minute, second);
+
+ // If the most significant bit of the least significant nibble is 1,
+ // the timezone offset is negative (fourth bit from the right => 0x08):
+ // localtime = UTC + tzOffset
+ // therefore
+ // UTC = localtime - tzOffset
+ let tzOctet = this.readHexOctet();
+ let tzOffset = this.octetToBCD(tzOctet & ~0x08) * 15 * 60 * 1000;
+ tzOffset = (tzOctet & 0x08) ? -tzOffset : tzOffset;
+ timestamp -= tzOffset;
+
+ return timestamp;
+ },
+
+ /**
+ * Write GSM TP-Service-Centre-Time-Stamp(TP-SCTS).
+ *
+ * @see 3GPP TS 23.040 9.2.3.11
+ */
+ writeTimestamp: function(date) {
+ this.writeSwappedNibbleBCDNum(date.getFullYear() - PDU_TIMESTAMP_YEAR_OFFSET);
+
+ // The value returned by getMonth() is an integer between 0 and 11.
+ // 0 is corresponds to January, 1 to February, and so on.
+ this.writeSwappedNibbleBCDNum(date.getMonth() + 1);
+ this.writeSwappedNibbleBCDNum(date.getDate());
+ this.writeSwappedNibbleBCDNum(date.getHours());
+ this.writeSwappedNibbleBCDNum(date.getMinutes());
+ this.writeSwappedNibbleBCDNum(date.getSeconds());
+
+ // the value returned by getTimezoneOffset() is the difference,
+ // in minutes, between UTC and local time.
+ // For example, if your time zone is UTC+10 (Australian Eastern Standard Time),
+ // -600 will be returned.
+ // In TS 23.040 9.2.3.11, the Time Zone field of TP-SCTS indicates
+ // the different between the local time and GMT.
+ // And expressed in quarters of an hours. (so need to divid by 15)
+ let zone = date.getTimezoneOffset() / 15;
+ let octet = this.BCDToOctet(zone);
+
+ // the bit3 of the Time Zone field represents the algebraic sign.
+ // (0: positive, 1: negative).
+ // For example, if the time zone is -0800 GMT,
+ // 480 will be returned by getTimezoneOffset().
+ // In this case, need to mark sign bit as 1. => 0x08
+ if (zone > 0) {
+ octet = octet | 0x08;
+ }
+ this.writeHexOctet(octet);
+ },
+
+ /**
+ * User data can be 7 bit (default alphabet) data, 8 bit data, or 16 bit
+ * (UCS2) data.
+ *
+ * @param msg
+ * message object for output.
+ * @param length
+ * length of user data to read in octets.
+ */
+ readUserData: function(msg, length) {
+ if (DEBUG) {
+ this.context.debug("Reading " + length + " bytes of user data.");
+ }
+
+ let paddingBits = 0;
+ if (msg.udhi) {
+ this.readUserDataHeader(msg);
+
+ if (msg.encoding == PDU_DCS_MSG_CODING_7BITS_ALPHABET) {
+ let headerBits = (msg.header.length + 1) * 8;
+ let headerSeptets = Math.ceil(headerBits / 7);
+
+ length -= headerSeptets;
+ paddingBits = headerSeptets * 7 - headerBits;
+ } else {
+ length -= (msg.header.length + 1);
+ }
+ }
+
+ if (DEBUG) {
+ this.context.debug("After header, " + length + " septets left of user data");
+ }
+
+ msg.body = null;
+ msg.data = null;
+
+ if (length <= 0) {
+ // No data to read.
+ return;
+ }
+
+ switch (msg.encoding) {
+ case PDU_DCS_MSG_CODING_7BITS_ALPHABET:
+ // 7 bit encoding allows 140 octets, which means 160 characters
+ // ((140x8) / 7 = 160 chars)
+ if (length > PDU_MAX_USER_DATA_7BIT) {
+ if (DEBUG) {
+ this.context.debug("PDU error: user data is too long: " + length);
+ }
+ break;
+ }
+
+ let langIndex = msg.udhi ? msg.header.langIndex : PDU_NL_IDENTIFIER_DEFAULT;
+ let langShiftIndex = msg.udhi ? msg.header.langShiftIndex : PDU_NL_IDENTIFIER_DEFAULT;
+ msg.body = this.readSeptetsToString(length, paddingBits, langIndex,
+ langShiftIndex);
+ break;
+ case PDU_DCS_MSG_CODING_8BITS_ALPHABET:
+ msg.data = this.readHexOctetArray(length);
+ break;
+ case PDU_DCS_MSG_CODING_16BITS_ALPHABET:
+ msg.body = this.readUCS2String(length);
+ break;
+ }
+ },
+
+ /**
+ * Read extra parameters if TP-PI is set.
+ *
+ * @param msg
+ * message object for output.
+ */
+ readExtraParams: function(msg) {
+ // Because each PDU octet is converted to two UCS2 char2, we should always
+ // get even messageStringLength in this#_processReceivedSms(). So, we'll
+ // always need two delimitors at the end.
+ if (this.context.Buf.getReadAvailable() <= 4) {
+ return;
+ }
+
+ // TP-Parameter-Indicator
+ let pi;
+ do {
+ // `The most significant bit in octet 1 and any other TP-PI octets which
+ // may be added later is reserved as an extension bit which when set to a
+ // 1 shall indicate that another TP-PI octet follows immediately
+ // afterwards.` ~ 3GPP TS 23.040 9.2.3.27
+ pi = this.readHexOctet();
+ } while (pi & PDU_PI_EXTENSION);
+
+ // `If the TP-UDL bit is set to "1" but the TP-DCS bit is set to "0" then
+ // the receiving entity shall for TP-DCS assume a value of 0x00, i.e. the
+ // 7bit default alphabet.` ~ 3GPP 23.040 9.2.3.27
+ msg.dcs = 0;
+ msg.encoding = PDU_DCS_MSG_CODING_7BITS_ALPHABET;
+
+ // TP-Protocol-Identifier
+ if (pi & PDU_PI_PROTOCOL_IDENTIFIER) {
+ this.readProtocolIndicator(msg);
+ }
+ // TP-Data-Coding-Scheme
+ if (pi & PDU_PI_DATA_CODING_SCHEME) {
+ this.readDataCodingScheme(msg);
+ }
+ // TP-User-Data-Length
+ if (pi & PDU_PI_USER_DATA_LENGTH) {
+ let userDataLength = this.readHexOctet();
+ this.readUserData(msg, userDataLength);
+ }
+ },
+
+ /**
+ * Read and decode a PDU-encoded message from the stream.
+ *
+ * TODO: add some basic sanity checks like:
+ * - do we have the minimum number of chars available
+ */
+ readMessage: function() {
+ // An empty message object. This gets filled below and then returned.
+ let msg = {
+ // D:DELIVER, DR:DELIVER-REPORT, S:SUBMIT, SR:SUBMIT-REPORT,
+ // ST:STATUS-REPORT, C:COMMAND
+ // M:Mandatory, O:Optional, X:Unavailable
+ // D DR S SR ST C
+ SMSC: null, // M M M M M M
+ mti: null, // M M M M M M
+ udhi: null, // M M O M M M
+ sender: null, // M X X X X X
+ recipient: null, // X X M X M M
+ pid: null, // M O M O O M
+ epid: null, // M O M O O M
+ dcs: null, // M O M O O X
+ mwi: null, // O O O O O O
+ replace: false, // O O O O O O
+ header: null, // M M O M M M
+ body: null, // M O M O O O
+ data: null, // M O M O O O
+ sentTimestamp: null, // M X X X X X
+ status: null, // X X X X M X
+ scts: null, // X X X M M X
+ dt: null, // X X X X M X
+ };
+
+ // SMSC info
+ let smscLength = this.readHexOctet();
+ if (smscLength > 0) {
+ let smscTypeOfAddress = this.readHexOctet();
+ // Subtract the type-of-address octet we just read from the length.
+ msg.SMSC = this.readSwappedNibbleExtendedBcdString(smscLength - 1);
+ if ((smscTypeOfAddress >> 4) == (PDU_TOA_INTERNATIONAL >> 4)) {
+ msg.SMSC = '+' + msg.SMSC;
+ }
+ }
+
+ // First octet of this SMS-DELIVER or SMS-SUBMIT message
+ let firstOctet = this.readHexOctet();
+ // Message Type Indicator
+ msg.mti = firstOctet & 0x03;
+ // User data header indicator
+ msg.udhi = firstOctet & PDU_UDHI;
+
+ switch (msg.mti) {
+ case PDU_MTI_SMS_RESERVED:
+ // `If an MS receives a TPDU with a "Reserved" value in the TP-MTI it
+ // shall process the message as if it were an "SMS-DELIVER" but store
+ // the message exactly as received.` ~ 3GPP TS 23.040 9.2.3.1
+ case PDU_MTI_SMS_DELIVER:
+ return this.readDeliverMessage(msg);
+ case PDU_MTI_SMS_STATUS_REPORT:
+ return this.readStatusReportMessage(msg);
+ default:
+ return null;
+ }
+ },
+
+ /**
+ * Helper for processing received SMS parcel data.
+ *
+ * @param length
+ * Length of SMS string in the incoming parcel.
+ *
+ * @return Message parsed or null for invalid message.
+ */
+ processReceivedSms: function(length) {
+ if (!length) {
+ if (DEBUG) this.context.debug("Received empty SMS!");
+ return [null, PDU_FCS_UNSPECIFIED];
+ }
+
+ let Buf = this.context.Buf;
+
+ // An SMS is a string, but we won't read it as such, so let's read the
+ // string length and then defer to PDU parsing helper.
+ let messageStringLength = Buf.readInt32();
+ if (DEBUG) this.context.debug("Got new SMS, length " + messageStringLength);
+ let message = this.readMessage();
+ if (DEBUG) this.context.debug("Got new SMS: " + JSON.stringify(message));
+
+ // Read string delimiters. See Buf.readString().
+ Buf.readStringDelimiter(length);
+
+ // Determine result
+ if (!message) {
+ return [null, PDU_FCS_UNSPECIFIED];
+ }
+
+ if (message.epid == PDU_PID_SHORT_MESSAGE_TYPE_0) {
+ // `A short message type 0 indicates that the ME must acknowledge receipt
+ // of the short message but shall discard its contents.` ~ 3GPP TS 23.040
+ // 9.2.3.9
+ return [null, PDU_FCS_OK];
+ }
+
+ if (message.messageClass == GECKO_SMS_MESSAGE_CLASSES[PDU_DCS_MSG_CLASS_2]) {
+ let RIL = this.context.RIL;
+ switch (message.epid) {
+ case PDU_PID_ANSI_136_R_DATA:
+ case PDU_PID_USIM_DATA_DOWNLOAD:
+ let ICCUtilsHelper = this.context.ICCUtilsHelper;
+ if (ICCUtilsHelper.isICCServiceAvailable("DATA_DOWNLOAD_SMS_PP")) {
+ // `If the service "data download via SMS Point-to-Point" is
+ // allocated and activated in the (U)SIM Service Table, ... then the
+ // ME shall pass the message transparently to the UICC using the
+ // ENVELOPE (SMS-PP DOWNLOAD).` ~ 3GPP TS 31.111 7.1.1.1
+ RIL.dataDownloadViaSMSPP(message);
+
+ // `the ME shall not display the message, or alert the user of a
+ // short message waiting.` ~ 3GPP TS 31.111 7.1.1.1
+ return [null, PDU_FCS_RESERVED];
+ }
+
+ // If the service "data download via SMS-PP" is not available in the
+ // (U)SIM Service Table, ..., then the ME shall store the message in
+ // EFsms in accordance with TS 31.102` ~ 3GPP TS 31.111 7.1.1.1
+
+ // Fall through.
+ default:
+ RIL.writeSmsToSIM(message);
+ break;
+ }
+ }
+
+ // TODO: Bug 739143: B2G SMS: Support SMS Storage Full event
+ if ((message.messageClass != GECKO_SMS_MESSAGE_CLASSES[PDU_DCS_MSG_CLASS_0]) && !true) {
+ // `When a mobile terminated message is class 0..., the MS shall display
+ // the message immediately and send a ACK to the SC ..., irrespective of
+ // whether there is memory available in the (U)SIM or ME.` ~ 3GPP 23.038
+ // clause 4.
+
+ if (message.messageClass == GECKO_SMS_MESSAGE_CLASSES[PDU_DCS_MSG_CLASS_2]) {
+ // `If all the short message storage at the MS is already in use, the
+ // MS shall return "memory capacity exceeded".` ~ 3GPP 23.038 clause 4.
+ return [null, PDU_FCS_MEMORY_CAPACITY_EXCEEDED];
+ }
+
+ return [null, PDU_FCS_UNSPECIFIED];
+ }
+
+ return [message, PDU_FCS_OK];
+ },
+
+ /**
+ * Read and decode a SMS-DELIVER PDU.
+ *
+ * @param msg
+ * message object for output.
+ */
+ readDeliverMessage: function(msg) {
+ // - Sender Address info -
+ let senderAddressLength = this.readHexOctet();
+ msg.sender = this.readAddress(senderAddressLength);
+ // - TP-Protocolo-Identifier -
+ this.readProtocolIndicator(msg);
+ // - TP-Data-Coding-Scheme -
+ this.readDataCodingScheme(msg);
+ // - TP-Service-Center-Time-Stamp -
+ msg.sentTimestamp = this.readTimestamp();
+ // - TP-User-Data-Length -
+ let userDataLength = this.readHexOctet();
+
+ // - TP-User-Data -
+ if (userDataLength > 0) {
+ this.readUserData(msg, userDataLength);
+ }
+
+ return msg;
+ },
+
+ /**
+ * Read and decode a SMS-STATUS-REPORT PDU.
+ *
+ * @param msg
+ * message object for output.
+ */
+ readStatusReportMessage: function(msg) {
+ // TP-Message-Reference
+ msg.messageRef = this.readHexOctet();
+ // TP-Recipient-Address
+ let recipientAddressLength = this.readHexOctet();
+ msg.recipient = this.readAddress(recipientAddressLength);
+ // TP-Service-Centre-Time-Stamp
+ msg.scts = this.readTimestamp();
+ // TP-Discharge-Time
+ msg.dt = this.readTimestamp();
+ // TP-Status
+ msg.status = this.readHexOctet();
+
+ this.readExtraParams(msg);
+
+ return msg;
+ },
+
+ /**
+ * Serialize a SMS-SUBMIT PDU message and write it to the output stream.
+ *
+ * This method expects that a data coding scheme has been chosen already
+ * and that the length of the user data payload in that encoding is known,
+ * too. Both go hand in hand together anyway.
+ *
+ * @param address
+ * String containing the address (number) of the SMS receiver
+ * @param userData
+ * String containing the message to be sent as user data
+ * @param dcs
+ * Data coding scheme. One of the PDU_DCS_MSG_CODING_*BITS_ALPHABET
+ * constants.
+ * @param userDataHeaderLength
+ * Length of embedded user data header, in bytes. The whole header
+ * size will be userDataHeaderLength + 1; 0 for no header.
+ * @param encodedBodyLength
+ * Length of the user data when encoded with the given DCS. For UCS2,
+ * in bytes; for 7-bit, in septets.
+ * @param langIndex
+ * Table index used for normal 7-bit encoded character lookup.
+ * @param langShiftIndex
+ * Table index used for escaped 7-bit encoded character lookup.
+ * @param requestStatusReport
+ * Request status report.
+ */
+ writeMessage: function(options) {
+ if (DEBUG) {
+ this.context.debug("writeMessage: " + JSON.stringify(options));
+ }
+ let Buf = this.context.Buf;
+ let address = options.number;
+ let body = options.body;
+ let dcs = options.dcs;
+ let userDataHeaderLength = options.userDataHeaderLength;
+ let encodedBodyLength = options.encodedBodyLength;
+ let langIndex = options.langIndex;
+ let langShiftIndex = options.langShiftIndex;
+
+ // SMS-SUBMIT Format:
+ //
+ // PDU Type - 1 octet
+ // Message Reference - 1 octet
+ // DA - Destination Address - 2 to 12 octets
+ // PID - Protocol Identifier - 1 octet
+ // DCS - Data Coding Scheme - 1 octet
+ // VP - Validity Period - 0, 1 or 7 octets
+ // UDL - User Data Length - 1 octet
+ // UD - User Data - 140 octets
+
+ let addressFormat = PDU_TOA_ISDN; // 81
+ if (address[0] == '+') {
+ addressFormat = PDU_TOA_INTERNATIONAL | PDU_TOA_ISDN; // 91
+ address = address.substring(1);
+ }
+ //TODO validity is unsupported for now
+ let validity = 0;
+
+ let headerOctets = (userDataHeaderLength ? userDataHeaderLength + 1 : 0);
+ let paddingBits;
+ let userDataLengthInSeptets;
+ let userDataLengthInOctets;
+ if (dcs == PDU_DCS_MSG_CODING_7BITS_ALPHABET) {
+ let headerSeptets = Math.ceil(headerOctets * 8 / 7);
+ userDataLengthInSeptets = headerSeptets + encodedBodyLength;
+ userDataLengthInOctets = Math.ceil(userDataLengthInSeptets * 7 / 8);
+ paddingBits = headerSeptets * 7 - headerOctets * 8;
+ } else {
+ userDataLengthInOctets = headerOctets + encodedBodyLength;
+ paddingBits = 0;
+ }
+
+ let pduOctetLength = 4 + // PDU Type, Message Ref, address length + format
+ Math.ceil(address.length / 2) +
+ 3 + // PID, DCS, UDL
+ userDataLengthInOctets;
+ if (validity) {
+ //TODO: add more to pduOctetLength
+ }
+
+ // Start the string. Since octets are represented in hex, we will need
+ // twice as many characters as octets.
+ Buf.writeInt32(pduOctetLength * 2);
+
+ // - PDU-TYPE-
+
+ // +--------+----------+---------+---------+--------+---------+
+ // | RP (1) | UDHI (1) | SRR (1) | VPF (2) | RD (1) | MTI (2) |
+ // +--------+----------+---------+---------+--------+---------+
+ // RP: 0 Reply path parameter is not set
+ // 1 Reply path parameter is set
+ // UDHI: 0 The UD Field contains only the short message
+ // 1 The beginning of the UD field contains a header in addition
+ // of the short message
+ // SRR: 0 A status report is not requested
+ // 1 A status report is requested
+ // VPF: bit4 bit3
+ // 0 0 VP field is not present
+ // 0 1 Reserved
+ // 1 0 VP field present an integer represented (relative)
+ // 1 1 VP field present a semi-octet represented (absolute)
+ // RD: Instruct the SMSC to accept(0) or reject(1) an SMS-SUBMIT
+ // for a short message still held in the SMSC which has the same
+ // MR and DA as a previously submitted short message from the
+ // same OA
+ // MTI: bit1 bit0 Message Type
+ // 0 0 SMS-DELIVER (SMSC ==> MS)
+ // 0 1 SMS-SUBMIT (MS ==> SMSC)
+
+ // PDU type. MTI is set to SMS-SUBMIT
+ let firstOctet = PDU_MTI_SMS_SUBMIT;
+
+ // Status-Report-Request
+ if (options.requestStatusReport) {
+ firstOctet |= PDU_SRI_SRR;
+ }
+
+ // Validity period
+ if (validity) {
+ //TODO: not supported yet, OR with one of PDU_VPF_*
+ }
+ // User data header indicator
+ if (headerOctets) {
+ firstOctet |= PDU_UDHI;
+ }
+ this.writeHexOctet(firstOctet);
+
+ // Message reference 00
+ this.writeHexOctet(0x00);
+
+ // - Destination Address -
+ this.writeHexOctet(address.length);
+ this.writeHexOctet(addressFormat);
+ this.writeSwappedNibbleBCD(address);
+
+ // - Protocol Identifier -
+ this.writeHexOctet(0x00);
+
+ // - Data coding scheme -
+ // For now it assumes bits 7..4 = 1111 except for the 16 bits use case
+ this.writeHexOctet(dcs);
+
+ // - Validity Period -
+ if (validity) {
+ this.writeHexOctet(validity);
+ }
+
+ // - User Data -
+ if (dcs == PDU_DCS_MSG_CODING_7BITS_ALPHABET) {
+ this.writeHexOctet(userDataLengthInSeptets);
+ } else {
+ this.writeHexOctet(userDataLengthInOctets);
+ }
+
+ if (headerOctets) {
+ this.writeUserDataHeader(options);
+ }
+
+ switch (dcs) {
+ case PDU_DCS_MSG_CODING_7BITS_ALPHABET:
+ this.writeStringAsSeptets(body, paddingBits, langIndex, langShiftIndex);
+ break;
+ case PDU_DCS_MSG_CODING_8BITS_ALPHABET:
+ // Unsupported.
+ break;
+ case PDU_DCS_MSG_CODING_16BITS_ALPHABET:
+ this.writeUCS2String(body);
+ break;
+ }
+
+ // End of the string. The string length is always even by definition, so
+ // we write two \0 delimiters.
+ Buf.writeUint16(0);
+ Buf.writeUint16(0);
+ },
+
+ /**
+ * Read GSM CBS message serial number.
+ *
+ * @param msg
+ * message object for output.
+ *
+ * @see 3GPP TS 23.041 section 9.4.1.2.1
+ */
+ readCbSerialNumber: function(msg) {
+ let Buf = this.context.Buf;
+ msg.serial = Buf.readUint8() << 8 | Buf.readUint8();
+ msg.geographicalScope = (msg.serial >>> 14) & 0x03;
+ msg.messageCode = (msg.serial >>> 4) & 0x03FF;
+ msg.updateNumber = msg.serial & 0x0F;
+ },
+
+ /**
+ * Read GSM CBS message message identifier.
+ *
+ * @param msg
+ * message object for output.
+ *
+ * @see 3GPP TS 23.041 section 9.4.1.2.2
+ */
+ readCbMessageIdentifier: function(msg) {
+ let Buf = this.context.Buf;
+ msg.messageId = Buf.readUint8() << 8 | Buf.readUint8();
+ },
+
+ /**
+ * Read ETWS information from message identifier and serial Number
+ * @param msg
+ * message object for output.
+ *
+ * @see 3GPP TS 23.041 section 9.4.1.2.1 & 9.4.1.2.2
+ */
+ readCbEtwsInfo: function(msg) {
+ if ((msg.format != CB_FORMAT_ETWS)
+ && (msg.messageId >= CB_GSM_MESSAGEID_ETWS_BEGIN)
+ && (msg.messageId <= CB_GSM_MESSAGEID_ETWS_END)) {
+ // `In the case of transmitting CBS message for ETWS, a part of
+ // Message Code can be used to command mobile terminals to activate
+ // emergency user alert and message popup in order to alert the users.`
+ msg.etws = {
+ emergencyUserAlert: msg.messageCode & 0x0200 ? true : false,
+ popup: msg.messageCode & 0x0100 ? true : false
+ };
+
+ let warningType = msg.messageId - CB_GSM_MESSAGEID_ETWS_BEGIN;
+ if (warningType < CB_ETWS_WARNING_TYPE_NAMES.length) {
+ msg.etws.warningType = warningType;
+ }
+ }
+ },
+
+ /**
+ * Read CBS Data Coding Scheme.
+ *
+ * @param msg
+ * message object for output.
+ *
+ * @see 3GPP TS 23.038 section 5.
+ */
+ readCbDataCodingScheme: function(msg) {
+ let dcs = this.context.Buf.readUint8();
+ if (DEBUG) this.context.debug("PDU: read CBS dcs: " + dcs);
+
+ let language = null, hasLanguageIndicator = false;
+ // `Any reserved codings shall be assumed to be the GSM 7bit default
+ // alphabet.`
+ let encoding = PDU_DCS_MSG_CODING_7BITS_ALPHABET;
+ let messageClass = PDU_DCS_MSG_CLASS_NORMAL;
+
+ switch (dcs & PDU_DCS_CODING_GROUP_BITS) {
+ case 0x00: // 0000
+ language = CB_DCS_LANG_GROUP_1[dcs & 0x0F];
+ break;
+
+ case 0x10: // 0001
+ switch (dcs & 0x0F) {
+ case 0x00:
+ hasLanguageIndicator = true;
+ break;
+ case 0x01:
+ encoding = PDU_DCS_MSG_CODING_16BITS_ALPHABET;
+ hasLanguageIndicator = true;
+ break;
+ }
+ break;
+
+ case 0x20: // 0010
+ language = CB_DCS_LANG_GROUP_2[dcs & 0x0F];
+ break;
+
+ case 0x40: // 01xx
+ case 0x50:
+ //case 0x60: Text Compression, not supported
+ //case 0x70: Text Compression, not supported
+ case 0x90: // 1001
+ encoding = (dcs & 0x0C);
+ if (encoding == 0x0C) {
+ encoding = PDU_DCS_MSG_CODING_7BITS_ALPHABET;
+ }
+ messageClass = (dcs & PDU_DCS_MSG_CLASS_BITS);
+ break;
+
+ case 0xF0:
+ encoding = (dcs & 0x04) ? PDU_DCS_MSG_CODING_8BITS_ALPHABET
+ : PDU_DCS_MSG_CODING_7BITS_ALPHABET;
+ switch(dcs & PDU_DCS_MSG_CLASS_BITS) {
+ case 0x01: messageClass = PDU_DCS_MSG_CLASS_USER_1; break;
+ case 0x02: messageClass = PDU_DCS_MSG_CLASS_USER_2; break;
+ case 0x03: messageClass = PDU_DCS_MSG_CLASS_3; break;
+ }
+ break;
+
+ case 0x30: // 0011 (Reserved)
+ case 0x80: // 1000 (Reserved)
+ case 0xA0: // 1010..1100 (Reserved)
+ case 0xB0:
+ case 0xC0:
+ break;
+
+ default:
+ throw new Error("Unsupported CBS data coding scheme: " + dcs);
+ }
+
+ msg.dcs = dcs;
+ msg.encoding = encoding;
+ msg.language = language;
+ msg.messageClass = GECKO_SMS_MESSAGE_CLASSES[messageClass];
+ msg.hasLanguageIndicator = hasLanguageIndicator;
+ },
+
+ /**
+ * Read GSM CBS message page parameter.
+ *
+ * @param msg
+ * message object for output.
+ *
+ * @see 3GPP TS 23.041 section 9.4.1.2.4
+ */
+ readCbPageParameter: function(msg) {
+ let octet = this.context.Buf.readUint8();
+ msg.pageIndex = (octet >>> 4) & 0x0F;
+ msg.numPages = octet & 0x0F;
+ if (!msg.pageIndex || !msg.numPages) {
+ // `If a mobile receives the code 0000 in either the first field or the
+ // second field then it shall treat the CBS message exactly the same as a
+ // CBS message with page parameter 0001 0001 (i.e. a single page message).`
+ msg.pageIndex = msg.numPages = 1;
+ }
+ },
+
+ /**
+ * Read ETWS Primary Notification message warning type.
+ *
+ * @param msg
+ * message object for output.
+ *
+ * @see 3GPP TS 23.041 section 9.3.24
+ */
+ readCbWarningType: function(msg) {
+ let Buf = this.context.Buf;
+ let word = Buf.readUint8() << 8 | Buf.readUint8();
+ msg.etws = {
+ warningType: (word >>> 9) & 0x7F,
+ popup: word & 0x80 ? true : false,
+ emergencyUserAlert: word & 0x100 ? true : false
+ };
+ },
+
+ /**
+ * Read GSM CB Data
+ *
+ * This parameter is a copy of the 'CBS-Message-Information-Page' as sent
+ * from the CBC to the BSC.
+ *
+ * @see 3GPP TS 23.041 section 9.4.1.2.5
+ */
+ readGsmCbData: function(msg, length) {
+ let Buf = this.context.Buf;
+ let bufAdapter = {
+ context: this.context,
+ readHexOctet: function() {
+ return Buf.readUint8();
+ }
+ };
+
+ msg.body = null;
+ msg.data = null;
+ switch (msg.encoding) {
+ case PDU_DCS_MSG_CODING_7BITS_ALPHABET:
+ msg.body = this.readSeptetsToString.call(bufAdapter,
+ Math.floor(length * 8 / 7), 0,
+ PDU_NL_IDENTIFIER_DEFAULT,
+ PDU_NL_IDENTIFIER_DEFAULT);
+ if (msg.hasLanguageIndicator) {
+ msg.language = msg.body.substring(0, 2);
+ msg.body = msg.body.substring(3);
+ }
+ break;
+
+ case PDU_DCS_MSG_CODING_8BITS_ALPHABET:
+ msg.data = Buf.readUint8Array(length);
+ break;
+
+ case PDU_DCS_MSG_CODING_16BITS_ALPHABET:
+ if (msg.hasLanguageIndicator) {
+ msg.language = this.readSeptetsToString.call(bufAdapter, 2, 0,
+ PDU_NL_IDENTIFIER_DEFAULT,
+ PDU_NL_IDENTIFIER_DEFAULT);
+ length -= 2;
+ }
+ msg.body = this.readUCS2String.call(bufAdapter, length);
+ break;
+ }
+
+ if (msg.data || !msg.body) {
+ return;
+ }
+
+ // According to 9.3.19 CBS-Message-Information-Page in TS 23.041:
+ // "
+ // This parameter is of a fixed length of 82 octets and carries up to and
+ // including 82 octets of user information. Where the user information is
+ // less than 82 octets, the remaining octets must be filled with padding.
+ // "
+ // According to 6.2.1.1 GSM 7 bit Default Alphabet and 6.2.3 UCS2 in
+ // TS 23.038, the padding character is <CR>.
+ for (let i = msg.body.length - 1; i >= 0; i--) {
+ if (msg.body.charAt(i) !== '\r') {
+ msg.body = msg.body.substring(0, i + 1);
+ break;
+ }
+ }
+ },
+
+ /**
+ * Read UMTS CB Data
+ *
+ * Octet Number(s) Parameter
+ * 1 Number-of-Pages
+ * 2 - 83 CBS-Message-Information-Page 1
+ * 84 CBS-Message-Information-Length 1
+ * ...
+ * CBS-Message-Information-Page n
+ * CBS-Message-Information-Length n
+ *
+ * @see 3GPP TS 23.041 section 9.4.2.2.5
+ */
+ readUmtsCbData: function(msg) {
+ let Buf = this.context.Buf;
+ let numOfPages = Buf.readUint8();
+ if (numOfPages < 0 || numOfPages > 15) {
+ throw new Error("Invalid numOfPages: " + numOfPages);
+ }
+
+ let bufAdapter = {
+ context: this.context,
+ readHexOctet: function() {
+ return Buf.readUint8();
+ }
+ };
+
+ let removePaddingCharactors = function (text) {
+ for (let i = text.length - 1; i >= 0; i--) {
+ if (text.charAt(i) !== '\r') {
+ return text.substring(0, i + 1);
+ }
+ }
+ return text;
+ };
+
+ let totalLength = 0, length, pageLengths = [];
+ for (let i = 0; i < numOfPages; i++) {
+ Buf.seekIncoming(CB_MSG_PAGE_INFO_SIZE);
+ length = Buf.readUint8();
+ totalLength += length;
+ pageLengths.push(length);
+ }
+
+ // Seek back to beginning of CB Data.
+ Buf.seekIncoming(-numOfPages * (CB_MSG_PAGE_INFO_SIZE + 1));
+
+ switch (msg.encoding) {
+ case PDU_DCS_MSG_CODING_7BITS_ALPHABET: {
+ let body;
+ msg.body = "";
+ for (let i = 0; i < numOfPages; i++) {
+ body = this.readSeptetsToString.call(bufAdapter,
+ Math.floor(pageLengths[i] * 8 / 7),
+ 0,
+ PDU_NL_IDENTIFIER_DEFAULT,
+ PDU_NL_IDENTIFIER_DEFAULT);
+ if (msg.hasLanguageIndicator) {
+ if (!msg.language) {
+ msg.language = body.substring(0, 2);
+ }
+ body = body.substring(3);
+ }
+
+ msg.body += removePaddingCharactors(body);
+
+ // Skip padding octets
+ Buf.seekIncoming(CB_MSG_PAGE_INFO_SIZE - pageLengths[i]);
+ // Read the octet of CBS-Message-Information-Length
+ Buf.readUint8();
+ }
+
+ break;
+ }
+
+ case PDU_DCS_MSG_CODING_8BITS_ALPHABET: {
+ msg.data = new Uint8Array(totalLength);
+ for (let i = 0, j = 0; i < numOfPages; i++) {
+ for (let pageLength = pageLengths[i]; pageLength > 0; pageLength--) {
+ msg.data[j++] = Buf.readUint8();
+ }
+
+ // Skip padding octets
+ Buf.seekIncoming(CB_MSG_PAGE_INFO_SIZE - pageLengths[i]);
+ // Read the octet of CBS-Message-Information-Length
+ Buf.readUint8();
+ }
+
+ break;
+ }
+
+ case PDU_DCS_MSG_CODING_16BITS_ALPHABET: {
+ msg.body = "";
+ for (let i = 0; i < numOfPages; i++) {
+ let pageLength = pageLengths[i];
+ if (msg.hasLanguageIndicator) {
+ if (!msg.language) {
+ msg.language = this.readSeptetsToString.call(bufAdapter,
+ 2,
+ 0,
+ PDU_NL_IDENTIFIER_DEFAULT,
+ PDU_NL_IDENTIFIER_DEFAULT);
+ } else {
+ Buf.readUint16();
+ }
+
+ pageLength -= 2;
+ }
+
+ msg.body += removePaddingCharactors(
+ this.readUCS2String.call(bufAdapter, pageLength));
+
+ // Skip padding octets
+ Buf.seekIncoming(CB_MSG_PAGE_INFO_SIZE - pageLengths[i]);
+ // Read the octet of CBS-Message-Information-Length
+ Buf.readUint8();
+ }
+
+ break;
+ }
+ }
+ },
+
+ /**
+ * Read Cell GSM/ETWS/UMTS Broadcast Message.
+ *
+ * @param pduLength
+ * total length of the incoming PDU in octets.
+ */
+ readCbMessage: function(pduLength) {
+ // Validity GSM ETWS UMTS
+ let msg = {
+ // Internally used in ril_worker:
+ serial: null, // O O O
+ updateNumber: null, // O O O
+ format: null, // O O O
+ dcs: 0x0F, // O X O
+ encoding: PDU_DCS_MSG_CODING_7BITS_ALPHABET, // O X O
+ hasLanguageIndicator: false, // O X O
+ data: null, // O X O
+ body: null, // O X O
+ pageIndex: 1, // O X X
+ numPages: 1, // O X X
+
+ // DOM attributes:
+ geographicalScope: null, // O O O
+ messageCode: null, // O O O
+ messageId: null, // O O O
+ language: null, // O X O
+ fullBody: null, // O X O
+ fullData: null, // O X O
+ messageClass: GECKO_SMS_MESSAGE_CLASSES[PDU_DCS_MSG_CLASS_NORMAL], // O x O
+ etws: null // ? O ?
+ /*{
+ warningType: null, // X O X
+ popup: false, // X O X
+ emergencyUserAlert: false, // X O X
+ }*/
+ };
+
+ if (pduLength <= CB_MESSAGE_SIZE_ETWS) {
+ msg.format = CB_FORMAT_ETWS;
+ return this.readEtwsCbMessage(msg);
+ }
+
+ if (pduLength <= CB_MESSAGE_SIZE_GSM) {
+ msg.format = CB_FORMAT_GSM;
+ return this.readGsmCbMessage(msg, pduLength);
+ }
+
+ if (pduLength >= CB_MESSAGE_SIZE_UMTS_MIN &&
+ pduLength <= CB_MESSAGE_SIZE_UMTS_MAX) {
+ msg.format = CB_FORMAT_UMTS;
+ return this.readUmtsCbMessage(msg);
+ }
+
+ throw new Error("Invalid PDU Length: " + pduLength);
+ },
+
+ /**
+ * Read UMTS CBS Message.
+ *
+ * @param msg
+ * message object for output.
+ *
+ * @see 3GPP TS 23.041 section 9.4.2
+ * @see 3GPP TS 25.324 section 10.2
+ */
+ readUmtsCbMessage: function(msg) {
+ let Buf = this.context.Buf;
+ let type = Buf.readUint8();
+ if (type != CB_UMTS_MESSAGE_TYPE_CBS) {
+ throw new Error("Unsupported UMTS Cell Broadcast message type: " + type);
+ }
+
+ this.readCbMessageIdentifier(msg);
+ this.readCbSerialNumber(msg);
+ this.readCbEtwsInfo(msg);
+ this.readCbDataCodingScheme(msg);
+ this.readUmtsCbData(msg);
+
+ return msg;
+ },
+
+ /**
+ * Read GSM Cell Broadcast Message.
+ *
+ * @param msg
+ * message object for output.
+ * @param pduLength
+ * total length of the incomint PDU in octets.
+ *
+ * @see 3GPP TS 23.041 clause 9.4.1.2
+ */
+ readGsmCbMessage: function(msg, pduLength) {
+ this.readCbSerialNumber(msg);
+ this.readCbMessageIdentifier(msg);
+ this.readCbEtwsInfo(msg);
+ this.readCbDataCodingScheme(msg);
+ this.readCbPageParameter(msg);
+
+ // GSM CB message header takes 6 octets.
+ this.readGsmCbData(msg, pduLength - 6);
+
+ return msg;
+ },
+
+ /**
+ * Read ETWS Primary Notification Message.
+ *
+ * @param msg
+ * message object for output.
+ *
+ * @see 3GPP TS 23.041 clause 9.4.1.3
+ */
+ readEtwsCbMessage: function(msg) {
+ this.readCbSerialNumber(msg);
+ this.readCbMessageIdentifier(msg);
+ this.readCbWarningType(msg);
+
+ // Octet 7..56 is Warning Security Information. However, according to
+ // section 9.4.1.3.6, `The UE shall ignore this parameter.` So we just skip
+ // processing it here.
+
+ return msg;
+ },
+
+ /**
+ * Read network name.
+ *
+ * @param len Length of the information element.
+ * @return
+ * {
+ * networkName: network name.
+ * shouldIncludeCi: Should Country's initials included in text string.
+ * }
+ * @see TS 24.008 clause 10.5.3.5a.
+ */
+ readNetworkName: function(len) {
+ // According to TS 24.008 Sec. 10.5.3.5a, the first octet is:
+ // bit 8: must be 1.
+ // bit 5-7: Text encoding.
+ // 000 - GSM default alphabet.
+ // 001 - UCS2 (16 bit).
+ // else - reserved.
+ // bit 4: MS should add the letters for Country's Initials and a space
+ // to the text string if this bit is true.
+ // bit 1-3: number of spare bits in last octet.
+
+ let codingInfo = this.readHexOctet();
+ if (!(codingInfo & 0x80)) {
+ return null;
+ }
+
+ let textEncoding = (codingInfo & 0x70) >> 4;
+ let shouldIncludeCountryInitials = !!(codingInfo & 0x08);
+ let spareBits = codingInfo & 0x07;
+ let resultString;
+
+ switch (textEncoding) {
+ case 0:
+ // GSM Default alphabet.
+ resultString = this.readSeptetsToString(
+ Math.floor(((len - 1) * 8 - spareBits) / 7), 0,
+ PDU_NL_IDENTIFIER_DEFAULT,
+ PDU_NL_IDENTIFIER_DEFAULT);
+ break;
+ case 1:
+ // UCS2 encoded.
+ resultString = this.context.ICCPDUHelper.readAlphaIdentifier(len - 1);
+ break;
+ default:
+ // Not an available text coding.
+ return null;
+ }
+
+ // TODO - Bug 820286: According to shouldIncludeCountryInitials, add
+ // country initials to the resulting string.
+ return resultString;
+ }
+};
+
+/**
+ * Provide buffer with bitwise read/write function so make encoding/decoding easier.
+ */
+function BitBufferHelperObject(/* unused */aContext) {
+ this.readBuffer = [];
+ this.writeBuffer = [];
+}
+BitBufferHelperObject.prototype = {
+ readCache: 0,
+ readCacheSize: 0,
+ readBuffer: null,
+ readIndex: 0,
+ writeCache: 0,
+ writeCacheSize: 0,
+ writeBuffer: null,
+
+ // Max length is 32 because we use integer as read/write cache.
+ // All read/write functions are implemented based on bitwise operation.
+ readBits: function(length) {
+ if (length <= 0 || length > 32) {
+ return null;
+ }
+
+ if (length > this.readCacheSize) {
+ let bytesToRead = Math.ceil((length - this.readCacheSize) / 8);
+ for(let i = 0; i < bytesToRead; i++) {
+ this.readCache = (this.readCache << 8) | (this.readBuffer[this.readIndex++] & 0xFF);
+ this.readCacheSize += 8;
+ }
+ }
+
+ let bitOffset = (this.readCacheSize - length),
+ resultMask = (1 << length) - 1,
+ result = 0;
+
+ result = (this.readCache >> bitOffset) & resultMask;
+ this.readCacheSize -= length;
+
+ return result;
+ },
+
+ backwardReadPilot: function(length) {
+ if (length <= 0) {
+ return;
+ }
+
+ // Zero-based position.
+ let bitIndexToRead = this.readIndex * 8 - this.readCacheSize - length;
+
+ if (bitIndexToRead < 0) {
+ return;
+ }
+
+ // Update readIndex, readCache, readCacheSize accordingly.
+ let readBits = bitIndexToRead % 8;
+ this.readIndex = Math.floor(bitIndexToRead / 8) + ((readBits) ? 1 : 0);
+ this.readCache = (readBits) ? this.readBuffer[this.readIndex - 1] : 0;
+ this.readCacheSize = (readBits) ? (8 - readBits) : 0;
+ },
+
+ writeBits: function(value, length) {
+ if (length <= 0 || length > 32) {
+ return;
+ }
+
+ let totalLength = length + this.writeCacheSize;
+
+ // 8-byte cache not full
+ if (totalLength < 8) {
+ let valueMask = (1 << length) - 1;
+ this.writeCache = (this.writeCache << length) | (value & valueMask);
+ this.writeCacheSize += length;
+ return;
+ }
+
+ // Deal with unaligned part
+ if (this.writeCacheSize) {
+ let mergeLength = 8 - this.writeCacheSize,
+ valueMask = (1 << mergeLength) - 1;
+
+ this.writeCache = (this.writeCache << mergeLength) | ((value >> (length - mergeLength)) & valueMask);
+ this.writeBuffer.push(this.writeCache & 0xFF);
+ length -= mergeLength;
+ }
+
+ // Aligned part, just copy
+ while (length >= 8) {
+ length -= 8;
+ this.writeBuffer.push((value >> length) & 0xFF);
+ }
+
+ // Rest part is saved into cache
+ this.writeCacheSize = length;
+ this.writeCache = value & ((1 << length) - 1);
+
+ return;
+ },
+
+ // Drop what still in read cache and goto next 8-byte alignment.
+ // There might be a better naming.
+ nextOctetAlign: function() {
+ this.readCache = 0;
+ this.readCacheSize = 0;
+ },
+
+ // Flush current write cache to Buf with padding 0s.
+ // There might be a better naming.
+ flushWithPadding: function() {
+ if (this.writeCacheSize) {
+ this.writeBuffer.push(this.writeCache << (8 - this.writeCacheSize));
+ }
+ this.writeCache = 0;
+ this.writeCacheSize = 0;
+ },
+
+ startWrite: function(dataBuffer) {
+ this.writeBuffer = dataBuffer;
+ this.writeCache = 0;
+ this.writeCacheSize = 0;
+ },
+
+ startRead: function(dataBuffer) {
+ this.readBuffer = dataBuffer;
+ this.readCache = 0;
+ this.readCacheSize = 0;
+ this.readIndex = 0;
+ },
+
+ getWriteBufferSize: function() {
+ return this.writeBuffer.length;
+ },
+
+ overwriteWriteBuffer: function(position, data) {
+ let writeLength = data.length;
+ if (writeLength + position >= this.writeBuffer.length) {
+ writeLength = this.writeBuffer.length - position;
+ }
+ for (let i = 0; i < writeLength; i++) {
+ this.writeBuffer[i + position] = data[i];
+ }
+ }
+};
+
+/**
+ * Helper for CDMA PDU
+ *
+ * Currently, some function are shared with GsmPDUHelper, they should be
+ * moved from GsmPDUHelper to a common object shared among GsmPDUHelper and
+ * CdmaPDUHelper.
+ */
+function CdmaPDUHelperObject(aContext) {
+ this.context = aContext;
+}
+CdmaPDUHelperObject.prototype = {
+ context: null,
+
+ // 1..........C
+ // Only "1234567890*#" is defined in C.S0005-D v2.0
+ dtmfChars: ".1234567890*#...",
+
+ /**
+ * Entry point for SMS encoding, the options object is made compatible
+ * with existing writeMessage() of GsmPDUHelper, but less key is used.
+ *
+ * Current used key in options:
+ * @param number
+ * String containing the address (number) of the SMS receiver
+ * @param body
+ * String containing the message to be sent, segmented part
+ * @param dcs
+ * Data coding scheme. One of the PDU_DCS_MSG_CODING_*BITS_ALPHABET
+ * constants.
+ * @param encodedBodyLength
+ * Length of the user data when encoded with the given DCS. For UCS2,
+ * in bytes; for 7-bit, in septets.
+ * @param requestStatusReport
+ * Request status report.
+ * @param segmentRef
+ * Reference number of concatenated SMS message
+ * @param segmentMaxSeq
+ * Total number of concatenated SMS message
+ * @param segmentSeq
+ * Sequence number of concatenated SMS message
+ */
+ writeMessage: function(options) {
+ if (DEBUG) {
+ this.context.debug("cdma_writeMessage: " + JSON.stringify(options));
+ }
+
+ // Get encoding
+ options.encoding = this.gsmDcsToCdmaEncoding(options.dcs);
+
+ // Common Header
+ if (options.segmentMaxSeq > 1) {
+ this.writeInt(PDU_CDMA_MSG_TELESERIVCIE_ID_WEMT);
+ } else {
+ this.writeInt(PDU_CDMA_MSG_TELESERIVCIE_ID_SMS);
+ }
+
+ this.writeInt(0);
+ this.writeInt(PDU_CDMA_MSG_CATEGORY_UNSPEC);
+
+ // Just fill out address info in byte, rild will encap them for us
+ let addrInfo = this.encodeAddr(options.number);
+ this.writeByte(addrInfo.digitMode);
+ this.writeByte(addrInfo.numberMode);
+ this.writeByte(addrInfo.numberType);
+ this.writeByte(addrInfo.numberPlan);
+ this.writeByte(addrInfo.address.length);
+ for (let i = 0; i < addrInfo.address.length; i++) {
+ this.writeByte(addrInfo.address[i]);
+ }
+
+ // Subaddress, not supported
+ this.writeByte(0); // Subaddress : Type
+ this.writeByte(0); // Subaddress : Odd
+ this.writeByte(0); // Subaddress : length
+
+ // User Data
+ let encodeResult = this.encodeUserData(options);
+ this.writeByte(encodeResult.length);
+ for (let i = 0; i < encodeResult.length; i++) {
+ this.writeByte(encodeResult[i]);
+ }
+
+ encodeResult = null;
+ },
+
+ /**
+ * Data writters
+ */
+ writeInt: function(value) {
+ this.context.Buf.writeInt32(value);
+ },
+
+ writeByte: function(value) {
+ this.context.Buf.writeInt32(value & 0xFF);
+ },
+
+ /**
+ * Transform GSM DCS to CDMA encoding.
+ */
+ gsmDcsToCdmaEncoding: function(encoding) {
+ switch (encoding) {
+ case PDU_DCS_MSG_CODING_7BITS_ALPHABET:
+ return PDU_CDMA_MSG_CODING_7BITS_ASCII;
+ case PDU_DCS_MSG_CODING_8BITS_ALPHABET:
+ return PDU_CDMA_MSG_CODING_OCTET;
+ case PDU_DCS_MSG_CODING_16BITS_ALPHABET:
+ return PDU_CDMA_MSG_CODING_UNICODE;
+ }
+ throw new Error("gsmDcsToCdmaEncoding(): Invalid GSM SMS DCS value: " + encoding);
+ },
+
+ /**
+ * Encode address into CDMA address format, as a byte array.
+ *
+ * @see 3GGP2 C.S0015-B 2.0, 3.4.3.3 Address Parameters
+ *
+ * @param address
+ * String of address to be encoded
+ */
+ encodeAddr: function(address) {
+ let result = {};
+
+ result.numberType = PDU_CDMA_MSG_ADDR_NUMBER_TYPE_UNKNOWN;
+ result.numberPlan = PDU_CDMA_MSG_ADDR_NUMBER_TYPE_UNKNOWN;
+
+ if (address[0] === '+') {
+ address = address.substring(1);
+ }
+
+ // Try encode with DTMF first
+ result.digitMode = PDU_CDMA_MSG_ADDR_DIGIT_MODE_DTMF;
+ result.numberMode = PDU_CDMA_MSG_ADDR_NUMBER_MODE_ANSI;
+
+ result.address = [];
+ for (let i = 0; i < address.length; i++) {
+ let addrDigit = this.dtmfChars.indexOf(address.charAt(i));
+ if (addrDigit < 0) {
+ result.digitMode = PDU_CDMA_MSG_ADDR_DIGIT_MODE_ASCII;
+ result.numberMode = PDU_CDMA_MSG_ADDR_NUMBER_MODE_ASCII;
+ result.address = [];
+ break;
+ }
+ result.address.push(addrDigit);
+ }
+
+ // Address can't be encoded with DTMF, then use 7-bit ASCII
+ if (result.digitMode !== PDU_CDMA_MSG_ADDR_DIGIT_MODE_DTMF) {
+ if (address.indexOf("@") !== -1) {
+ result.numberType = PDU_CDMA_MSG_ADDR_NUMBER_TYPE_NATIONAL;
+ }
+
+ for (let i = 0; i < address.length; i++) {
+ result.address.push(address.charCodeAt(i) & 0x7F);
+ }
+ }
+
+ return result;
+ },
+
+ /**
+ * Encode SMS contents in options into CDMA userData field.
+ * Corresponding and required subparameters will be added automatically.
+ *
+ * @see 3GGP2 C.S0015-B 2.0, 3.4.3.7 Bearer Data
+ * 4.5 Bearer Data Parameters
+ *
+ * Current used key in options:
+ * @param body
+ * String containing the message to be sent, segmented part
+ * @param encoding
+ * Encoding method of CDMA, can be transformed from GSM DCS by function
+ * cdmaPduHelp.gsmDcsToCdmaEncoding()
+ * @param encodedBodyLength
+ * Length of the user data when encoded with the given DCS. For UCS2,
+ * in bytes; for 7-bit, in septets.
+ * @param requestStatusReport
+ * Request status report.
+ * @param segmentRef
+ * Reference number of concatenated SMS message
+ * @param segmentMaxSeq
+ * Total number of concatenated SMS message
+ * @param segmentSeq
+ * Sequence number of concatenated SMS message
+ */
+ encodeUserData: function(options) {
+ let userDataBuffer = [];
+ this.context.BitBufferHelper.startWrite(userDataBuffer);
+
+ // Message Identifier
+ this.encodeUserDataMsgId(options);
+
+ // User Data
+ this.encodeUserDataMsg(options);
+
+ // Reply Option
+ this.encodeUserDataReplyOption(options);
+
+ return userDataBuffer;
+ },
+
+ /**
+ * User data subparameter encoder : Message Identifier
+ *
+ * @see 3GGP2 C.S0015-B 2.0, 4.5.1 Message Identifier
+ */
+ encodeUserDataMsgId: function(options) {
+ let BitBufferHelper = this.context.BitBufferHelper;
+ BitBufferHelper.writeBits(PDU_CDMA_MSG_USERDATA_MSG_ID, 8);
+ BitBufferHelper.writeBits(3, 8);
+ BitBufferHelper.writeBits(PDU_CDMA_MSG_TYPE_SUBMIT, 4);
+ BitBufferHelper.writeBits(1, 16); // TODO: How to get message ID?
+ if (options.segmentMaxSeq > 1) {
+ BitBufferHelper.writeBits(1, 1);
+ } else {
+ BitBufferHelper.writeBits(0, 1);
+ }
+
+ BitBufferHelper.flushWithPadding();
+ },
+
+ /**
+ * User data subparameter encoder : User Data
+ *
+ * @see 3GGP2 C.S0015-B 2.0, 4.5.2 User Data
+ */
+ encodeUserDataMsg: function(options) {
+ let BitBufferHelper = this.context.BitBufferHelper;
+ BitBufferHelper.writeBits(PDU_CDMA_MSG_USERDATA_BODY, 8);
+ // Reserve space for length
+ BitBufferHelper.writeBits(0, 8);
+ let lengthPosition = BitBufferHelper.getWriteBufferSize();
+
+ BitBufferHelper.writeBits(options.encoding, 5);
+
+ // Add user data header for message segement
+ let msgBody = options.body,
+ msgBodySize = (options.encoding === PDU_CDMA_MSG_CODING_7BITS_ASCII ?
+ options.encodedBodyLength :
+ msgBody.length);
+ if (options.segmentMaxSeq > 1) {
+ if (options.encoding === PDU_CDMA_MSG_CODING_7BITS_ASCII) {
+ BitBufferHelper.writeBits(msgBodySize + 7, 8); // Required length for user data header, in septet(7-bit)
+
+ BitBufferHelper.writeBits(5, 8); // total header length 5 bytes
+ BitBufferHelper.writeBits(PDU_IEI_CONCATENATED_SHORT_MESSAGES_8BIT, 8); // header id 0
+ BitBufferHelper.writeBits(3, 8); // length of element for id 0 is 3
+ BitBufferHelper.writeBits(options.segmentRef & 0xFF, 8); // Segement reference
+ BitBufferHelper.writeBits(options.segmentMaxSeq & 0xFF, 8); // Max segment
+ BitBufferHelper.writeBits(options.segmentSeq & 0xFF, 8); // Current segment
+ BitBufferHelper.writeBits(0, 1); // Padding to make header data septet(7-bit) aligned
+ } else {
+ if (options.encoding === PDU_CDMA_MSG_CODING_UNICODE) {
+ BitBufferHelper.writeBits(msgBodySize + 3, 8); // Required length for user data header, in 16-bit
+ } else {
+ BitBufferHelper.writeBits(msgBodySize + 6, 8); // Required length for user data header, in octet(8-bit)
+ }
+
+ BitBufferHelper.writeBits(5, 8); // total header length 5 bytes
+ BitBufferHelper.writeBits(PDU_IEI_CONCATENATED_SHORT_MESSAGES_8BIT, 8); // header id 0
+ BitBufferHelper.writeBits(3, 8); // length of element for id 0 is 3
+ BitBufferHelper.writeBits(options.segmentRef & 0xFF, 8); // Segement reference
+ BitBufferHelper.writeBits(options.segmentMaxSeq & 0xFF, 8); // Max segment
+ BitBufferHelper.writeBits(options.segmentSeq & 0xFF, 8); // Current segment
+ }
+ } else {
+ BitBufferHelper.writeBits(msgBodySize, 8);
+ }
+
+ // Encode message based on encoding method
+ const langTable = PDU_NL_LOCKING_SHIFT_TABLES[PDU_NL_IDENTIFIER_DEFAULT];
+ const langShiftTable = PDU_NL_SINGLE_SHIFT_TABLES[PDU_NL_IDENTIFIER_DEFAULT];
+ for (let i = 0; i < msgBody.length; i++) {
+ switch (options.encoding) {
+ case PDU_CDMA_MSG_CODING_OCTET: {
+ let msgDigit = msgBody.charCodeAt(i);
+ BitBufferHelper.writeBits(msgDigit, 8);
+ break;
+ }
+ case PDU_CDMA_MSG_CODING_7BITS_ASCII: {
+ let msgDigit = msgBody.charCodeAt(i),
+ msgDigitChar = msgBody.charAt(i);
+
+ if (msgDigit >= 32) {
+ BitBufferHelper.writeBits(msgDigit, 7);
+ } else {
+ msgDigit = langTable.indexOf(msgDigitChar);
+
+ if (msgDigit === PDU_NL_EXTENDED_ESCAPE) {
+ break;
+ }
+ if (msgDigit >= 0) {
+ BitBufferHelper.writeBits(msgDigit, 7);
+ } else {
+ msgDigit = langShiftTable.indexOf(msgDigitChar);
+ if (msgDigit == -1) {
+ throw new Error("'" + msgDigitChar + "' is not in 7 bit alphabet "
+ + langIndex + ":" + langShiftIndex + "!");
+ }
+
+ if (msgDigit === PDU_NL_RESERVED_CONTROL) {
+ break;
+ }
+
+ BitBufferHelper.writeBits(PDU_NL_EXTENDED_ESCAPE, 7);
+ BitBufferHelper.writeBits(msgDigit, 7);
+ }
+ }
+ break;
+ }
+ case PDU_CDMA_MSG_CODING_UNICODE: {
+ let msgDigit = msgBody.charCodeAt(i);
+ BitBufferHelper.writeBits(msgDigit, 16);
+ break;
+ }
+ }
+ }
+ BitBufferHelper.flushWithPadding();
+
+ // Fill length
+ let currentPosition = BitBufferHelper.getWriteBufferSize();
+ BitBufferHelper.overwriteWriteBuffer(lengthPosition - 1, [currentPosition - lengthPosition]);
+ },
+
+ /**
+ * User data subparameter encoder : Reply Option
+ *
+ * @see 3GGP2 C.S0015-B 2.0, 4.5.11 Reply Option
+ */
+ encodeUserDataReplyOption: function(options) {
+ if (options.requestStatusReport) {
+ let BitBufferHelper = this.context.BitBufferHelper;
+ BitBufferHelper.writeBits(PDU_CDMA_MSG_USERDATA_REPLY_OPTION, 8);
+ BitBufferHelper.writeBits(1, 8);
+ BitBufferHelper.writeBits(0, 1); // USER_ACK_REQ
+ BitBufferHelper.writeBits(1, 1); // DAK_REQ
+ BitBufferHelper.flushWithPadding();
+ }
+ },
+
+ /**
+ * Entry point for SMS decoding, the returned object is made compatible
+ * with existing readMessage() of GsmPDUHelper
+ */
+ readMessage: function() {
+ let message = {};
+
+ // Teleservice Identifier
+ message.teleservice = this.readInt();
+
+ // Message Type
+ let isServicePresent = this.readByte();
+ if (isServicePresent) {
+ message.messageType = PDU_CDMA_MSG_TYPE_BROADCAST;
+ } else {
+ if (message.teleservice) {
+ message.messageType = PDU_CDMA_MSG_TYPE_P2P;
+ } else {
+ message.messageType = PDU_CDMA_MSG_TYPE_ACK;
+ }
+ }
+
+ // Service Category
+ message.service = this.readInt();
+
+ // Originated Address
+ let addrInfo = {};
+ addrInfo.digitMode = (this.readInt() & 0x01);
+ addrInfo.numberMode = (this.readInt() & 0x01);
+ addrInfo.numberType = (this.readInt() & 0x01);
+ addrInfo.numberPlan = (this.readInt() & 0x01);
+ addrInfo.addrLength = this.readByte();
+ addrInfo.address = [];
+ for (let i = 0; i < addrInfo.addrLength; i++) {
+ addrInfo.address.push(this.readByte());
+ }
+ message.sender = this.decodeAddr(addrInfo);
+
+ // Originated Subaddress
+ addrInfo.Type = (this.readInt() & 0x07);
+ addrInfo.Odd = (this.readByte() & 0x01);
+ addrInfo.addrLength = this.readByte();
+ for (let i = 0; i < addrInfo.addrLength; i++) {
+ let addrDigit = this.readByte();
+ message.sender += String.fromCharCode(addrDigit);
+ }
+
+ // Bearer Data
+ this.decodeUserData(message);
+
+ // Bearer Data Sub-Parameter: User Data
+ let userData = message[PDU_CDMA_MSG_USERDATA_BODY];
+ [message.header, message.body, message.encoding, message.data] =
+ (userData) ? [userData.header, userData.body, userData.encoding, userData.data]
+ : [null, null, null, null];
+
+ // Bearer Data Sub-Parameter: Message Status
+ // Success Delivery (0) if both Message Status and User Data are absent.
+ // Message Status absent (-1) if only User Data is available.
+ let msgStatus = message[PDU_CDMA_MSG_USER_DATA_MSG_STATUS];
+ [message.errorClass, message.msgStatus] =
+ (msgStatus) ? [msgStatus.errorClass, msgStatus.msgStatus]
+ : ((message.body) ? [-1, -1] : [0, 0]);
+
+ // Transform message to GSM msg
+ let msg = {
+ SMSC: "",
+ mti: 0,
+ udhi: 0,
+ sender: message.sender,
+ recipient: null,
+ pid: PDU_PID_DEFAULT,
+ epid: PDU_PID_DEFAULT,
+ dcs: 0,
+ mwi: null,
+ replace: false,
+ header: message.header,
+ body: message.body,
+ data: message.data,
+ sentTimestamp: message[PDU_CDMA_MSG_USERDATA_TIMESTAMP],
+ language: message[PDU_CDMA_LANGUAGE_INDICATOR],
+ status: null,
+ scts: null,
+ dt: null,
+ encoding: message.encoding,
+ messageClass: GECKO_SMS_MESSAGE_CLASSES[PDU_DCS_MSG_CLASS_NORMAL],
+ messageType: message.messageType,
+ serviceCategory: message.service,
+ subMsgType: message[PDU_CDMA_MSG_USERDATA_MSG_ID].msgType,
+ msgId: message[PDU_CDMA_MSG_USERDATA_MSG_ID].msgId,
+ errorClass: message.errorClass,
+ msgStatus: message.msgStatus,
+ teleservice: message.teleservice
+ };
+
+ return msg;
+ },
+
+ /**
+ * Helper for processing received SMS parcel data.
+ *
+ * @param length
+ * Length of SMS string in the incoming parcel.
+ *
+ * @return Message parsed or null for invalid message.
+ */
+ processReceivedSms: function(length) {
+ if (!length) {
+ if (DEBUG) this.context.debug("Received empty SMS!");
+ return [null, PDU_FCS_UNSPECIFIED];
+ }
+
+ let message = this.readMessage();
+ if (DEBUG) this.context.debug("Got new SMS: " + JSON.stringify(message));
+
+ // Determine result
+ if (!message) {
+ return [null, PDU_FCS_UNSPECIFIED];
+ }
+
+ return [message, PDU_FCS_OK];
+ },
+
+ /**
+ * Data readers
+ */
+ readInt: function() {
+ return this.context.Buf.readInt32();
+ },
+
+ readByte: function() {
+ return (this.context.Buf.readInt32() & 0xFF);
+ },
+
+ /**
+ * Decode CDMA address data into address string
+ *
+ * @see 3GGP2 C.S0015-B 2.0, 3.4.3.3 Address Parameters
+ *
+ * Required key in addrInfo
+ * @param addrLength
+ * Length of address
+ * @param digitMode
+ * Address encoding method
+ * @param address
+ * Array of encoded address data
+ */
+ decodeAddr: function(addrInfo) {
+ let result = "";
+ for (let i = 0; i < addrInfo.addrLength; i++) {
+ if (addrInfo.digitMode === PDU_CDMA_MSG_ADDR_DIGIT_MODE_DTMF) {
+ result += this.dtmfChars.charAt(addrInfo.address[i]);
+ } else {
+ result += String.fromCharCode(addrInfo.address[i]);
+ }
+ }
+ return result;
+ },
+
+ /**
+ * Read userData in parcel buffer and decode into message object.
+ * Each subparameter will be stored in corresponding key.
+ *
+ * @see 3GGP2 C.S0015-B 2.0, 3.4.3.7 Bearer Data
+ * 4.5 Bearer Data Parameters
+ */
+ decodeUserData: function(message) {
+ let userDataLength = this.readInt();
+
+ while (userDataLength > 0) {
+ let id = this.readByte(),
+ length = this.readByte(),
+ userDataBuffer = [];
+
+ for (let i = 0; i < length; i++) {
+ userDataBuffer.push(this.readByte());
+ }
+
+ this.context.BitBufferHelper.startRead(userDataBuffer);
+
+ switch (id) {
+ case PDU_CDMA_MSG_USERDATA_MSG_ID:
+ message[id] = this.decodeUserDataMsgId();
+ break;
+ case PDU_CDMA_MSG_USERDATA_BODY:
+ message[id] = this.decodeUserDataMsg(message[PDU_CDMA_MSG_USERDATA_MSG_ID].userHeader);
+ break;
+ case PDU_CDMA_MSG_USERDATA_TIMESTAMP:
+ message[id] = this.decodeUserDataTimestamp();
+ break;
+ case PDU_CDMA_MSG_USERDATA_REPLY_OPTION:
+ message[id] = this.decodeUserDataReplyOption();
+ break;
+ case PDU_CDMA_LANGUAGE_INDICATOR:
+ message[id] = this.decodeLanguageIndicator();
+ break;
+ case PDU_CDMA_MSG_USERDATA_CALLBACK_NUMBER:
+ message[id] = this.decodeUserDataCallbackNumber();
+ break;
+ case PDU_CDMA_MSG_USER_DATA_MSG_STATUS:
+ message[id] = this.decodeUserDataMsgStatus();
+ break;
+ }
+
+ userDataLength -= (length + 2);
+ userDataBuffer = [];
+ }
+ },
+
+ /**
+ * User data subparameter decoder: Message Identifier
+ *
+ * @see 3GGP2 C.S0015-B 2.0, 4.5.1 Message Identifier
+ */
+ decodeUserDataMsgId: function() {
+ let result = {};
+ let BitBufferHelper = this.context.BitBufferHelper;
+ result.msgType = BitBufferHelper.readBits(4);
+ result.msgId = BitBufferHelper.readBits(16);
+ result.userHeader = BitBufferHelper.readBits(1);
+
+ return result;
+ },
+
+ /**
+ * Decode user data header, we only care about segment information
+ * on CDMA.
+ *
+ * This function is mostly copied from gsmPduHelper.readUserDataHeader() but
+ * change the read function, because CDMA user header decoding is't byte-wise
+ * aligned.
+ */
+ decodeUserDataHeader: function(encoding) {
+ let BitBufferHelper = this.context.BitBufferHelper;
+ let header = {},
+ headerSize = BitBufferHelper.readBits(8),
+ userDataHeaderSize = headerSize + 1,
+ headerPaddingBits = 0;
+
+ // Calculate header size
+ if (encoding === PDU_DCS_MSG_CODING_7BITS_ALPHABET) {
+ // Length is in 7-bit
+ header.length = Math.ceil(userDataHeaderSize * 8 / 7);
+ // Calulate padding length
+ headerPaddingBits = (header.length * 7) - (userDataHeaderSize * 8);
+ } else if (encoding === PDU_DCS_MSG_CODING_8BITS_ALPHABET) {
+ header.length = userDataHeaderSize;
+ } else {
+ header.length = userDataHeaderSize / 2;
+ }
+
+ while (headerSize) {
+ let identifier = BitBufferHelper.readBits(8),
+ length = BitBufferHelper.readBits(8);
+
+ headerSize -= (2 + length);
+
+ switch (identifier) {
+ case PDU_IEI_CONCATENATED_SHORT_MESSAGES_8BIT: {
+ let ref = BitBufferHelper.readBits(8),
+ max = BitBufferHelper.readBits(8),
+ seq = BitBufferHelper.readBits(8);
+ if (max && seq && (seq <= max)) {
+ header.segmentRef = ref;
+ header.segmentMaxSeq = max;
+ header.segmentSeq = seq;
+ }
+ break;
+ }
+ case PDU_IEI_APPLICATION_PORT_ADDRESSING_SCHEME_8BIT: {
+ let dstp = BitBufferHelper.readBits(8),
+ orip = BitBufferHelper.readBits(8);
+ if ((dstp < PDU_APA_RESERVED_8BIT_PORTS)
+ || (orip < PDU_APA_RESERVED_8BIT_PORTS)) {
+ // 3GPP TS 23.040 clause 9.2.3.24.3: "A receiving entity shall
+ // ignore any information element where the value of the
+ // Information-Element-Data is Reserved or not supported"
+ break;
+ }
+ header.destinationPort = dstp;
+ header.originatorPort = orip;
+ break;
+ }
+ case PDU_IEI_APPLICATION_PORT_ADDRESSING_SCHEME_16BIT: {
+ let dstp = (BitBufferHelper.readBits(8) << 8) | BitBufferHelper.readBits(8),
+ orip = (BitBufferHelper.readBits(8) << 8) | BitBufferHelper.readBits(8);
+ // 3GPP TS 23.040 clause 9.2.3.24.4: "A receiving entity shall
+ // ignore any information element where the value of the
+ // Information-Element-Data is Reserved or not supported"
+ if ((dstp < PDU_APA_VALID_16BIT_PORTS)
+ && (orip < PDU_APA_VALID_16BIT_PORTS)) {
+ header.destinationPort = dstp;
+ header.originatorPort = orip;
+ }
+ break;
+ }
+ case PDU_IEI_CONCATENATED_SHORT_MESSAGES_16BIT: {
+ let ref = (BitBufferHelper.readBits(8) << 8) | BitBufferHelper.readBits(8),
+ max = BitBufferHelper.readBits(8),
+ seq = BitBufferHelper.readBits(8);
+ if (max && seq && (seq <= max)) {
+ header.segmentRef = ref;
+ header.segmentMaxSeq = max;
+ header.segmentSeq = seq;
+ }
+ break;
+ }
+ case PDU_IEI_NATIONAL_LANGUAGE_SINGLE_SHIFT: {
+ let langShiftIndex = BitBufferHelper.readBits(8);
+ if (langShiftIndex < PDU_NL_SINGLE_SHIFT_TABLES.length) {
+ header.langShiftIndex = langShiftIndex;
+ }
+ break;
+ }
+ case PDU_IEI_NATIONAL_LANGUAGE_LOCKING_SHIFT: {
+ let langIndex = BitBufferHelper.readBits(8);
+ if (langIndex < PDU_NL_LOCKING_SHIFT_TABLES.length) {
+ header.langIndex = langIndex;
+ }
+ break;
+ }
+ case PDU_IEI_SPECIAL_SMS_MESSAGE_INDICATION: {
+ let msgInd = BitBufferHelper.readBits(8) & 0xFF,
+ msgCount = BitBufferHelper.readBits(8);
+ /*
+ * TS 23.040 V6.8.1 Sec 9.2.3.24.2
+ * bits 1 0 : basic message indication type
+ * bits 4 3 2 : extended message indication type
+ * bits 6 5 : Profile id
+ * bit 7 : storage type
+ */
+ let storeType = msgInd & PDU_MWI_STORE_TYPE_BIT;
+ header.mwi = {};
+ mwi = header.mwi;
+
+ if (storeType == PDU_MWI_STORE_TYPE_STORE) {
+ // Store message because TP_UDH indicates so, note this may override
+ // the setting in DCS, but that is expected
+ mwi.discard = false;
+ } else if (mwi.discard === undefined) {
+ // storeType == PDU_MWI_STORE_TYPE_DISCARD
+ // only override mwi.discard here if it hasn't already been set
+ mwi.discard = true;
+ }
+
+ mwi.msgCount = msgCount & 0xFF;
+ mwi.active = mwi.msgCount > 0;
+
+ if (DEBUG) {
+ this.context.debug("MWI in TP_UDH received: " + JSON.stringify(mwi));
+ }
+ break;
+ }
+ default:
+ // Drop unsupported id
+ for (let i = 0; i < length; i++) {
+ BitBufferHelper.readBits(8);
+ }
+ }
+ }
+
+ // Consume padding bits
+ if (headerPaddingBits) {
+ BitBufferHelper.readBits(headerPaddingBits);
+ }
+
+ return header;
+ },
+
+ getCdmaMsgEncoding: function(encoding) {
+ // Determine encoding method
+ switch (encoding) {
+ case PDU_CDMA_MSG_CODING_7BITS_ASCII:
+ case PDU_CDMA_MSG_CODING_IA5:
+ case PDU_CDMA_MSG_CODING_7BITS_GSM:
+ return PDU_DCS_MSG_CODING_7BITS_ALPHABET;
+ case PDU_CDMA_MSG_CODING_OCTET:
+ case PDU_CDMA_MSG_CODING_IS_91:
+ case PDU_CDMA_MSG_CODING_LATIN_HEBREW:
+ case PDU_CDMA_MSG_CODING_LATIN:
+ return PDU_DCS_MSG_CODING_8BITS_ALPHABET;
+ case PDU_CDMA_MSG_CODING_UNICODE:
+ case PDU_CDMA_MSG_CODING_SHIFT_JIS:
+ case PDU_CDMA_MSG_CODING_KOREAN:
+ return PDU_DCS_MSG_CODING_16BITS_ALPHABET;
+ }
+ return null;
+ },
+
+ decodeCdmaPDUMsg: function(encoding, msgType, msgBodySize) {
+ const langTable = PDU_NL_LOCKING_SHIFT_TABLES[PDU_NL_IDENTIFIER_DEFAULT];
+ const langShiftTable = PDU_NL_SINGLE_SHIFT_TABLES[PDU_NL_IDENTIFIER_DEFAULT];
+ let BitBufferHelper = this.context.BitBufferHelper;
+ let result = "";
+ let msgDigit;
+ switch (encoding) {
+ case PDU_CDMA_MSG_CODING_OCTET: // TODO : Require Test
+ while(msgBodySize > 0) {
+ msgDigit = String.fromCharCode(BitBufferHelper.readBits(8));
+ result += msgDigit;
+ msgBodySize--;
+ }
+ break;
+ case PDU_CDMA_MSG_CODING_IS_91: // TODO : Require Test
+ // Referenced from android code
+ switch (msgType) {
+ case PDU_CDMA_MSG_CODING_IS_91_TYPE_SMS:
+ case PDU_CDMA_MSG_CODING_IS_91_TYPE_SMS_FULL:
+ case PDU_CDMA_MSG_CODING_IS_91_TYPE_VOICEMAIL_STATUS:
+ while(msgBodySize > 0) {
+ msgDigit = String.fromCharCode(BitBufferHelper.readBits(6) + 0x20);
+ result += msgDigit;
+ msgBodySize--;
+ }
+ break;
+ case PDU_CDMA_MSG_CODING_IS_91_TYPE_CLI:
+ let addrInfo = {};
+ addrInfo.digitMode = PDU_CDMA_MSG_ADDR_DIGIT_MODE_DTMF;
+ addrInfo.numberMode = PDU_CDMA_MSG_ADDR_NUMBER_MODE_ANSI;
+ addrInfo.numberType = PDU_CDMA_MSG_ADDR_NUMBER_TYPE_UNKNOWN;
+ addrInfo.numberPlan = PDU_CDMA_MSG_ADDR_NUMBER_PLAN_UNKNOWN;
+ addrInfo.addrLength = msgBodySize;
+ addrInfo.address = [];
+ for (let i = 0; i < addrInfo.addrLength; i++) {
+ addrInfo.address.push(BitBufferHelper.readBits(4));
+ }
+ result = this.decodeAddr(addrInfo);
+ break;
+ }
+ // Fall through.
+ case PDU_CDMA_MSG_CODING_7BITS_ASCII:
+ case PDU_CDMA_MSG_CODING_IA5: // TODO : Require Test
+ while(msgBodySize > 0) {
+ msgDigit = BitBufferHelper.readBits(7);
+ if (msgDigit >= 32) {
+ msgDigit = String.fromCharCode(msgDigit);
+ } else {
+ if (msgDigit !== PDU_NL_EXTENDED_ESCAPE) {
+ msgDigit = langTable[msgDigit];
+ } else {
+ msgDigit = BitBufferHelper.readBits(7);
+ msgBodySize--;
+ msgDigit = langShiftTable[msgDigit];
+ }
+ }
+ result += msgDigit;
+ msgBodySize--;
+ }
+ break;
+ case PDU_CDMA_MSG_CODING_UNICODE:
+ while(msgBodySize > 0) {
+ msgDigit = String.fromCharCode(BitBufferHelper.readBits(16));
+ result += msgDigit;
+ msgBodySize--;
+ }
+ break;
+ case PDU_CDMA_MSG_CODING_7BITS_GSM: // TODO : Require Test
+ while(msgBodySize > 0) {
+ msgDigit = BitBufferHelper.readBits(7);
+ if (msgDigit !== PDU_NL_EXTENDED_ESCAPE) {
+ msgDigit = langTable[msgDigit];
+ } else {
+ msgDigit = BitBufferHelper.readBits(7);
+ msgBodySize--;
+ msgDigit = langShiftTable[msgDigit];
+ }
+ result += msgDigit;
+ msgBodySize--;
+ }
+ break;
+ case PDU_CDMA_MSG_CODING_LATIN: // TODO : Require Test
+ // Reference : http://en.wikipedia.org/wiki/ISO/IEC_8859-1
+ while(msgBodySize > 0) {
+ msgDigit = String.fromCharCode(BitBufferHelper.readBits(8));
+ result += msgDigit;
+ msgBodySize--;
+ }
+ break;
+ case PDU_CDMA_MSG_CODING_LATIN_HEBREW: // TODO : Require Test
+ // Reference : http://en.wikipedia.org/wiki/ISO/IEC_8859-8
+ while(msgBodySize > 0) {
+ msgDigit = BitBufferHelper.readBits(8);
+ if (msgDigit === 0xDF) {
+ msgDigit = String.fromCharCode(0x2017);
+ } else if (msgDigit === 0xFD) {
+ msgDigit = String.fromCharCode(0x200E);
+ } else if (msgDigit === 0xFE) {
+ msgDigit = String.fromCharCode(0x200F);
+ } else if (msgDigit >= 0xE0 && msgDigit <= 0xFA) {
+ msgDigit = String.fromCharCode(0x4F0 + msgDigit);
+ } else {
+ msgDigit = String.fromCharCode(msgDigit);
+ }
+ result += msgDigit;
+ msgBodySize--;
+ }
+ break;
+ case PDU_CDMA_MSG_CODING_SHIFT_JIS:
+ // Reference : http://msdn.microsoft.com/en-US/goglobal/cc305152.aspx
+ // http://demo.icu-project.org/icu-bin/convexp?conv=Shift_JIS
+ let shift_jis_message = [];
+
+ while (msgBodySize > 0) {
+ shift_jis_message.push(BitBufferHelper.readBits(8));
+ msgBodySize--;
+ }
+
+ let decoder = new TextDecoder("shift_jis");
+ result = decoder.decode(new Uint8Array(shift_jis_message));
+ break;
+ case PDU_CDMA_MSG_CODING_KOREAN:
+ case PDU_CDMA_MSG_CODING_GSM_DCS:
+ // Fall through.
+ default:
+ break;
+ }
+ return result;
+ },
+
+ /**
+ * User data subparameter decoder : User Data
+ *
+ * @see 3GGP2 C.S0015-B 2.0, 4.5.2 User Data
+ */
+ decodeUserDataMsg: function(hasUserHeader) {
+ let BitBufferHelper = this.context.BitBufferHelper;
+ let result = {},
+ encoding = BitBufferHelper.readBits(5),
+ msgType;
+
+ if (encoding === PDU_CDMA_MSG_CODING_IS_91) {
+ msgType = BitBufferHelper.readBits(8);
+ }
+ result.encoding = this.getCdmaMsgEncoding(encoding);
+
+ let msgBodySize = BitBufferHelper.readBits(8);
+
+ // For segmented SMS, a user header is included before sms content
+ if (hasUserHeader) {
+ result.header = this.decodeUserDataHeader(result.encoding);
+ // header size is included in body size, they are decoded
+ msgBodySize -= result.header.length;
+ }
+
+ // Store original payload if enconding is OCTET for further handling of WAP Push, etc.
+ if (encoding === PDU_CDMA_MSG_CODING_OCTET && msgBodySize > 0) {
+ result.data = new Uint8Array(msgBodySize);
+ for (let i = 0; i < msgBodySize; i++) {
+ result.data[i] = BitBufferHelper.readBits(8);
+ }
+ BitBufferHelper.backwardReadPilot(8 * msgBodySize);
+ }
+
+ // Decode sms content
+ result.body = this.decodeCdmaPDUMsg(encoding, msgType, msgBodySize);
+
+ return result;
+ },
+
+ decodeBcd: function(value) {
+ return ((value >> 4) & 0xF) * 10 + (value & 0x0F);
+ },
+
+ /**
+ * User data subparameter decoder : Time Stamp
+ *
+ * @see 3GGP2 C.S0015-B 2.0, 4.5.4 Message Center Time Stamp
+ */
+ decodeUserDataTimestamp: function() {
+ let BitBufferHelper = this.context.BitBufferHelper;
+ let year = this.decodeBcd(BitBufferHelper.readBits(8)),
+ month = this.decodeBcd(BitBufferHelper.readBits(8)) - 1,
+ date = this.decodeBcd(BitBufferHelper.readBits(8)),
+ hour = this.decodeBcd(BitBufferHelper.readBits(8)),
+ min = this.decodeBcd(BitBufferHelper.readBits(8)),
+ sec = this.decodeBcd(BitBufferHelper.readBits(8));
+
+ if (year >= 96 && year <= 99) {
+ year += 1900;
+ } else {
+ year += 2000;
+ }
+
+ let result = (new Date(year, month, date, hour, min, sec, 0)).valueOf();
+
+ return result;
+ },
+
+ /**
+ * User data subparameter decoder : Reply Option
+ *
+ * @see 3GGP2 C.S0015-B 2.0, 4.5.11 Reply Option
+ */
+ decodeUserDataReplyOption: function() {
+ let replyAction = this.context.BitBufferHelper.readBits(4),
+ result = { userAck: (replyAction & 0x8) ? true : false,
+ deliverAck: (replyAction & 0x4) ? true : false,
+ readAck: (replyAction & 0x2) ? true : false,
+ report: (replyAction & 0x1) ? true : false
+ };
+
+ return result;
+ },
+
+ /**
+ * User data subparameter decoder : Language Indicator
+ *
+ * @see 3GGP2 C.S0015-B 2.0, 4.5.14 Language Indicator
+ */
+ decodeLanguageIndicator: function() {
+ let language = this.context.BitBufferHelper.readBits(8);
+ let result = CB_CDMA_LANG_GROUP[language];
+ return result;
+ },
+
+ /**
+ * User data subparameter decoder : Call-Back Number
+ *
+ * @see 3GGP2 C.S0015-B 2.0, 4.5.15 Call-Back Number
+ */
+ decodeUserDataCallbackNumber: function() {
+ let BitBufferHelper = this.context.BitBufferHelper;
+ let digitMode = BitBufferHelper.readBits(1);
+ if (digitMode) {
+ let numberType = BitBufferHelper.readBits(3),
+ numberPlan = BitBufferHelper.readBits(4);
+ }
+ let numberFields = BitBufferHelper.readBits(8),
+ result = "";
+ for (let i = 0; i < numberFields; i++) {
+ if (digitMode === PDU_CDMA_MSG_ADDR_DIGIT_MODE_DTMF) {
+ let addrDigit = BitBufferHelper.readBits(4);
+ result += this.dtmfChars.charAt(addrDigit);
+ } else {
+ let addrDigit = BitBufferHelper.readBits(8);
+ result += String.fromCharCode(addrDigit);
+ }
+ }
+
+ return result;
+ },
+
+ /**
+ * User data subparameter decoder : Message Status
+ *
+ * @see 3GGP2 C.S0015-B 2.0, 4.5.21 Message Status
+ */
+ decodeUserDataMsgStatus: function() {
+ let BitBufferHelper = this.context.BitBufferHelper;
+ let result = {
+ errorClass: BitBufferHelper.readBits(2),
+ msgStatus: BitBufferHelper.readBits(6)
+ };
+
+ return result;
+ },
+
+ /**
+ * Decode information record parcel.
+ */
+ decodeInformationRecord: function() {
+ let Buf = this.context.Buf;
+ let records = [];
+ let numOfRecords = Buf.readInt32();
+
+ let type;
+ let record;
+ for (let i = 0; i < numOfRecords; i++) {
+ record = {};
+ type = Buf.readInt32();
+
+ switch (type) {
+ /*
+ * Every type is encaped by ril, except extended display
+ */
+ case PDU_CDMA_INFO_REC_TYPE_DISPLAY:
+ case PDU_CDMA_INFO_REC_TYPE_EXTENDED_DISPLAY:
+ record.display = Buf.readString();
+ break;
+ case PDU_CDMA_INFO_REC_TYPE_CALLED_PARTY_NUMBER:
+ record.calledNumber = {};
+ record.calledNumber.number = Buf.readString();
+ record.calledNumber.type = Buf.readInt32();
+ record.calledNumber.plan = Buf.readInt32();
+ record.calledNumber.pi = Buf.readInt32();
+ record.calledNumber.si = Buf.readInt32();
+ break;
+ case PDU_CDMA_INFO_REC_TYPE_CALLING_PARTY_NUMBER:
+ record.callingNumber = {};
+ record.callingNumber.number = Buf.readString();
+ record.callingNumber.type = Buf.readInt32();
+ record.callingNumber.plan = Buf.readInt32();
+ record.callingNumber.pi = Buf.readInt32();
+ record.callingNumber.si = Buf.readInt32();
+ break;
+ case PDU_CDMA_INFO_REC_TYPE_CONNECTED_NUMBER:
+ record.connectedNumber = {};
+ record.connectedNumber.number = Buf.readString();
+ record.connectedNumber.type = Buf.readInt32();
+ record.connectedNumber.plan = Buf.readInt32();
+ record.connectedNumber.pi = Buf.readInt32();
+ record.connectedNumber.si = Buf.readInt32();
+ break;
+ case PDU_CDMA_INFO_REC_TYPE_SIGNAL:
+ record.signal = {};
+ if (!Buf.readInt32()) { // Non-zero if signal is present.
+ Buf.seekIncoming(3 * Buf.UINT32_SIZE);
+ continue;
+ }
+ record.signal.type = Buf.readInt32();
+ record.signal.alertPitch = Buf.readInt32();
+ record.signal.signal = Buf.readInt32();
+ break;
+ case PDU_CDMA_INFO_REC_TYPE_REDIRECTING_NUMBER:
+ record.redirect = {};
+ record.redirect.number = Buf.readString();
+ record.redirect.type = Buf.readInt32();
+ record.redirect.plan = Buf.readInt32();
+ record.redirect.pi = Buf.readInt32();
+ record.redirect.si = Buf.readInt32();
+ record.redirect.reason = Buf.readInt32();
+ break;
+ case PDU_CDMA_INFO_REC_TYPE_LINE_CONTROL:
+ record.lineControl = {};
+ record.lineControl.polarityIncluded = Buf.readInt32();
+ record.lineControl.toggle = Buf.readInt32();
+ record.lineControl.reverse = Buf.readInt32();
+ record.lineControl.powerDenial = Buf.readInt32();
+ break;
+ case PDU_CDMA_INFO_REC_TYPE_T53_CLIR:
+ record.clirCause = Buf.readInt32();
+ break;
+ case PDU_CDMA_INFO_REC_TYPE_T53_AUDIO_CONTROL:
+ record.audioControl = {};
+ record.audioControl.upLink = Buf.readInt32();
+ record.audioControl.downLink = Buf.readInt32();
+ break;
+ case PDU_CDMA_INFO_REC_TYPE_T53_RELEASE:
+ // Fall through
+ default:
+ throw new Error("UNSOLICITED_CDMA_INFO_REC(), Unsupported information record type " + type + "\n");
+ }
+
+ records.push(record);
+ }
+
+ return records;
+ }
+};
+
+/**
+ * Helper for processing ICC PDUs.
+ */
+function ICCPDUHelperObject(aContext) {
+ this.context = aContext;
+}
+ICCPDUHelperObject.prototype = {
+ context: null,
+
+ /**
+ * Read GSM 8-bit unpacked octets,
+ * which are default 7-bit alphabets with bit 8 set to 0.
+ *
+ * @param numOctets
+ * Number of octets to be read.
+ */
+ read8BitUnpackedToString: function(numOctets) {
+ let GsmPDUHelper = this.context.GsmPDUHelper;
+
+ let ret = "";
+ let escapeFound = false;
+ let i;
+ const langTable = PDU_NL_LOCKING_SHIFT_TABLES[PDU_NL_IDENTIFIER_DEFAULT];
+ const langShiftTable = PDU_NL_SINGLE_SHIFT_TABLES[PDU_NL_IDENTIFIER_DEFAULT];
+
+ for(i = 0; i < numOctets; i++) {
+ let octet = GsmPDUHelper.readHexOctet();
+ if (octet == 0xff) {
+ i++;
+ break;
+ }
+
+ if (escapeFound) {
+ escapeFound = false;
+ if (octet == PDU_NL_EXTENDED_ESCAPE) {
+ // According to 3GPP TS 23.038, section 6.2.1.1, NOTE 1, "On
+ // receipt of this code, a receiving entity shall display a space
+ // until another extensiion table is defined."
+ ret += " ";
+ } else if (octet == PDU_NL_RESERVED_CONTROL) {
+ // According to 3GPP TS 23.038 B.2, "This code represents a control
+ // character and therefore must not be used for language specific
+ // characters."
+ ret += " ";
+ } else {
+ ret += langShiftTable[octet];
+ }
+ } else if (octet == PDU_NL_EXTENDED_ESCAPE) {
+ escapeFound = true;
+ } else {
+ ret += langTable[octet];
+ }
+ }
+
+ let Buf = this.context.Buf;
+ Buf.seekIncoming((numOctets - i) * Buf.PDU_HEX_OCTET_SIZE);
+ return ret;
+ },
+
+ /**
+ * Write GSM 8-bit unpacked octets.
+ *
+ * @param numOctets Number of total octets to be writen, including trailing
+ * 0xff.
+ * @param str String to be written. Could be null.
+ *
+ * @return The string has been written into Buf. "" if str is null.
+ */
+ writeStringTo8BitUnpacked: function(numOctets, str) {
+ const langTable = PDU_NL_LOCKING_SHIFT_TABLES[PDU_NL_IDENTIFIER_DEFAULT];
+ const langShiftTable = PDU_NL_SINGLE_SHIFT_TABLES[PDU_NL_IDENTIFIER_DEFAULT];
+
+ let GsmPDUHelper = this.context.GsmPDUHelper;
+
+ // If the character is GSM extended alphabet, two octets will be written.
+ // So we need to keep track of number of octets to be written.
+ let i, j;
+ let len = str ? str.length : 0;
+ for (i = 0, j = 0; i < len && j < numOctets; i++) {
+ let c = str.charAt(i);
+ let octet = langTable.indexOf(c);
+
+ if (octet == -1) {
+ // Make sure we still have enough space to write two octets.
+ if (j + 2 > numOctets) {
+ break;
+ }
+
+ octet = langShiftTable.indexOf(c);
+ if (octet == -1) {
+ // Fallback to ASCII space.
+ octet = langTable.indexOf(' ');
+ } else {
+ GsmPDUHelper.writeHexOctet(PDU_NL_EXTENDED_ESCAPE);
+ j++;
+ }
+ }
+ GsmPDUHelper.writeHexOctet(octet);
+ j++;
+ }
+
+ // trailing 0xff
+ while (j++ < numOctets) {
+ GsmPDUHelper.writeHexOctet(0xff);
+ }
+
+ return (str) ? str.substring(0, i) : "";
+ },
+
+ /**
+ * Write UCS2 String on UICC.
+ * The default choose 0x81 or 0x82 encode, otherwise use 0x80 encode.
+ *
+ * @see TS 102.221, Annex A.
+ * @param numOctets
+ * Total number of octets to be written. This includes the length of
+ * alphaId and the length of trailing unused octets(0xff).
+ * @param str
+ * String to be written.
+ *
+ * @return The string has been written into Buf.
+ */
+ writeICCUCS2String: function(numOctets, str) {
+ let GsmPDUHelper = this.context.GsmPDUHelper;
+ let scheme = 0x80;
+ let basePointer;
+
+ if (str.length > 2) {
+ let min = 0xFFFF;
+ let max = 0;
+ for (let i = 0; i < str.length; i++) {
+ let code = str.charCodeAt(i);
+ // filter out GSM Default Alphabet character
+ if (code & 0xFF80) {
+ if (min > code) {
+ min = code;
+ }
+ if (max < code) {
+ max = code;
+ }
+ }
+ }
+
+ // 0x81 and 0x82 only support 'half-page', i.e., 128 characters.
+ if ((max - min) >= 0 && (max - min) < 128) {
+ // 0x81 base pointer is 0hhh hhhh h000 0000, and bit 16 is set to zero,
+ // therefore it can't compute 0x8000~0xFFFF.
+ // Since 0x81 only support 128 characters,
+ // either XX00~XX7f(bit 8 are 0) or XX80~XXff(bit 8 are 1)
+ if (((min & 0x7f80) == (max & 0x7f80)) &&
+ ((max & 0x8000) == 0)) {
+ scheme = 0x81;
+ basePointer = min & 0x7f80;
+ } else {
+ scheme = 0x82;
+ basePointer = min;
+ }
+ }
+ }
+
+ switch (scheme) {
+ /**
+ * +------+---------+---------+---------+---------+------+------+
+ * | 0x80 | Ch1_msb | Ch1_lsb | Ch2_msb | Ch2_lsb | 0xff | 0xff |
+ * +------+---------+---------+---------+---------+------+------+
+ */
+ case 0x80: {
+ // 0x80 support UCS2 0000~ffff
+ GsmPDUHelper.writeHexOctet(0x80);
+ numOctets--;
+ // Now the str is UCS2 string, each character will take 2 octets.
+ if (str.length * 2 > numOctets) {
+ str = str.substring(0, Math.floor(numOctets / 2));
+ }
+ GsmPDUHelper.writeUCS2String(str);
+
+ // trailing 0xff
+ for (let i = str.length * 2; i < numOctets; i++) {
+ GsmPDUHelper.writeHexOctet(0xff);
+ }
+ return str;
+ }
+ /**
+ * +------+-----+--------------+-----+-----+-----+--------+------+
+ * | 0x81 | len | base_pointer | Ch1 | Ch2 | ... | Ch_len | 0xff |
+ * +------+-----+--------------+-----+-----+-----+--------+------+
+ *
+ * len: The length of characters.
+ * base_pointer: 0hhh hhhh h000 0000
+ * Ch_n: bit 8 = 0
+ * GSM default alphabets
+ * bit 8 = 1
+ * UCS2 character whose char code is (Ch_n - base_pointer) | 0x80
+ *
+ */
+ case 0x81: {
+ GsmPDUHelper.writeHexOctet(0x81);
+
+ if (str.length > (numOctets - 3)) {
+ str = str.substring(0, numOctets - 3);
+ }
+
+ GsmPDUHelper.writeHexOctet(str.length);
+ GsmPDUHelper.writeHexOctet((basePointer >> 7) & 0xff);
+ numOctets -= 3;
+ break;
+ }
+ /* +------+-----+------------------+------------------+-----+-----+-----+--------+
+ * | 0x82 | len | base_pointer_msb | base_pointer_lsb | Ch1 | Ch2 | ... | Ch_len |
+ * +------+-----+------------------+------------------+-----+-----+-----+--------+
+ *
+ * len: The length of characters.
+ * base_pointer_msb, base_pointer_lsn: base_pointer
+ * Ch_n: bit 8 = 0
+ * GSM default alphabets
+ * bit 8 = 1
+ * UCS2 character whose char code is (Ch_n - base_pointer) | 0x80
+ */
+ case 0x82: {
+ GsmPDUHelper.writeHexOctet(0x82);
+
+ if (str.length > (numOctets - 4)) {
+ str = str.substring(0, numOctets - 4);
+ }
+
+ GsmPDUHelper.writeHexOctet(str.length);
+ GsmPDUHelper.writeHexOctet((basePointer >> 8) & 0xff);
+ GsmPDUHelper.writeHexOctet(basePointer & 0xff);
+ numOctets -= 4;
+ break;
+ }
+ }
+
+ if (scheme == 0x81 || scheme == 0x82) {
+ for (let i = 0; i < str.length; i++) {
+ let code = str.charCodeAt(i);
+
+ // bit 8 = 0,
+ // GSM default alphabets
+ if (code >> 8 == 0) {
+ GsmPDUHelper.writeHexOctet(code & 0x7F);
+ } else {
+ // bit 8 = 1,
+ // UCS2 character whose char code is (code - basePointer) | 0x80
+ GsmPDUHelper.writeHexOctet((code - basePointer) | 0x80);
+ }
+ }
+
+ // trailing 0xff
+ for (let i = 0; i < numOctets - str.length; i++) {
+ GsmPDUHelper.writeHexOctet(0xff);
+ }
+ }
+ return str;
+ },
+
+ /**
+ * Read UCS2 String on UICC.
+ *
+ * @see TS 101.221, Annex A.
+ * @param scheme
+ * Coding scheme for UCS2 on UICC. One of 0x80, 0x81 or 0x82.
+ * @param numOctets
+ * Number of octets to be read as UCS2 string.
+ */
+ readICCUCS2String: function(scheme, numOctets) {
+ let Buf = this.context.Buf;
+ let GsmPDUHelper = this.context.GsmPDUHelper;
+
+ let str = "";
+ switch (scheme) {
+ /**
+ * +------+---------+---------+---------+---------+------+------+
+ * | 0x80 | Ch1_msb | Ch1_lsb | Ch2_msb | Ch2_lsb | 0xff | 0xff |
+ * +------+---------+---------+---------+---------+------+------+
+ */
+ case 0x80:
+ let isOdd = numOctets % 2;
+ let i;
+ for (i = 0; i < numOctets - isOdd; i += 2) {
+ let code = (GsmPDUHelper.readHexOctet() << 8) | GsmPDUHelper.readHexOctet();
+ if (code == 0xffff) {
+ i += 2;
+ break;
+ }
+ str += String.fromCharCode(code);
+ }
+
+ // Skip trailing 0xff
+ Buf.seekIncoming((numOctets - i) * Buf.PDU_HEX_OCTET_SIZE);
+ break;
+ case 0x81: // Fall through
+ case 0x82:
+ /**
+ * +------+-----+--------+-----+-----+-----+--------+------+
+ * | 0x81 | len | offset | Ch1 | Ch2 | ... | Ch_len | 0xff |
+ * +------+-----+--------+-----+-----+-----+--------+------+
+ *
+ * len : The length of characters.
+ * offset : 0hhh hhhh h000 0000
+ * Ch_n: bit 8 = 0
+ * GSM default alphabets
+ * bit 8 = 1
+ * UCS2 character whose char code is (Ch_n & 0x7f) + offset
+ *
+ * +------+-----+------------+------------+-----+-----+-----+--------+
+ * | 0x82 | len | offset_msb | offset_lsb | Ch1 | Ch2 | ... | Ch_len |
+ * +------+-----+------------+------------+-----+-----+-----+--------+
+ *
+ * len : The length of characters.
+ * offset_msb, offset_lsn: offset
+ * Ch_n: bit 8 = 0
+ * GSM default alphabets
+ * bit 8 = 1
+ * UCS2 character whose char code is (Ch_n & 0x7f) + offset
+ */
+ let len = GsmPDUHelper.readHexOctet();
+ let offset, headerLen;
+ if (scheme == 0x81) {
+ offset = GsmPDUHelper.readHexOctet() << 7;
+ headerLen = 2;
+ } else {
+ offset = (GsmPDUHelper.readHexOctet() << 8) | GsmPDUHelper.readHexOctet();
+ headerLen = 3;
+ }
+
+ for (let i = 0; i < len; i++) {
+ let ch = GsmPDUHelper.readHexOctet();
+ if (ch & 0x80) {
+ // UCS2
+ str += String.fromCharCode((ch & 0x7f) + offset);
+ } else {
+ // GSM 8bit
+ let count = 0, gotUCS2 = 0;
+ while ((i + count + 1 < len)) {
+ count++;
+ if (GsmPDUHelper.readHexOctet() & 0x80) {
+ gotUCS2 = 1;
+ break;
+ }
+ }
+ // Unread.
+ // +1 for the GSM alphabet indexed at i,
+ Buf.seekIncoming(-1 * (count + 1) * Buf.PDU_HEX_OCTET_SIZE);
+ str += this.read8BitUnpackedToString(count + 1 - gotUCS2);
+ i += count - gotUCS2;
+ }
+ }
+
+ // Skipping trailing 0xff
+ Buf.seekIncoming((numOctets - len - headerLen) * Buf.PDU_HEX_OCTET_SIZE);
+ break;
+ }
+ return str;
+ },
+
+ /**
+ * Read Alpha Id and Dialling number from TS TS 151.011 clause 10.5.1
+ *
+ * @param recordSize The size of linear fixed record.
+ */
+ readAlphaIdDiallingNumber: function(recordSize) {
+ let Buf = this.context.Buf;
+ let length = Buf.readInt32();
+
+ let alphaLen = recordSize - ADN_FOOTER_SIZE_BYTES;
+ let alphaId = this.readAlphaIdentifier(alphaLen);
+
+ let number = this.readNumberWithLength();
+
+ // Skip unused octet, CCP
+ Buf.seekIncoming(Buf.PDU_HEX_OCTET_SIZE);
+
+ let extRecordNumber = this.context.GsmPDUHelper.readHexOctet();
+ Buf.readStringDelimiter(length);
+
+ let contact = null;
+ if (alphaId || number) {
+ contact = {alphaId: alphaId,
+ number: number,
+ extRecordNumber: extRecordNumber};
+ }
+
+ return contact;
+ },
+
+ /**
+ * Write Alpha Identifier and Dialling number from TS 151.011 clause 10.5.1
+ *
+ * @param recordSize The size of linear fixed record.
+ * @param alphaId Alpha Identifier to be written.
+ * @param number Dialling Number to be written.
+ * @param extRecordNumber The record identifier of the EXT.
+ *
+ * @return An object contains the alphaId and number
+ * that have been written into Buf.
+ */
+ writeAlphaIdDiallingNumber: function(recordSize, alphaId, number, extRecordNumber) {
+ let Buf = this.context.Buf;
+ let GsmPDUHelper = this.context.GsmPDUHelper;
+
+ // Write String length
+ let strLen = recordSize * 2;
+ Buf.writeInt32(strLen);
+
+ let alphaLen = recordSize - ADN_FOOTER_SIZE_BYTES;
+ let writtenAlphaId = this.writeAlphaIdentifier(alphaLen, alphaId);
+ let writtenNumber = this.writeNumberWithLength(number);
+
+ // Write unused CCP octet 0xff.
+ GsmPDUHelper.writeHexOctet(0xff);
+ GsmPDUHelper.writeHexOctet((extRecordNumber != null) ? extRecordNumber : 0xff);
+
+ Buf.writeStringDelimiter(strLen);
+
+ return {alphaId: writtenAlphaId,
+ number: writtenNumber};
+ },
+
+ /**
+ * Read Alpha Identifier.
+ *
+ * @see TS 131.102
+ *
+ * @param numOctets
+ * Number of octets to be read.
+ *
+ * It uses either
+ * 1. SMS default 7-bit alphabet with bit 8 set to 0.
+ * 2. UCS2 string.
+ *
+ * Unused bytes should be set to 0xff.
+ */
+ readAlphaIdentifier: function(numOctets) {
+ if (numOctets === 0) {
+ return "";
+ }
+
+ let temp;
+ // Read the 1st octet to determine the encoding.
+ if ((temp = this.context.GsmPDUHelper.readHexOctet()) == 0x80 ||
+ temp == 0x81 ||
+ temp == 0x82) {
+ numOctets--;
+ return this.readICCUCS2String(temp, numOctets);
+ } else {
+ let Buf = this.context.Buf;
+ Buf.seekIncoming(-1 * Buf.PDU_HEX_OCTET_SIZE);
+ return this.read8BitUnpackedToString(numOctets);
+ }
+ },
+
+ /**
+ * Write Alpha Identifier.
+ *
+ * @param numOctets
+ * Total number of octets to be written. This includes the length of
+ * alphaId and the length of trailing unused octets(0xff).
+ * @param alphaId
+ * Alpha Identifier to be written.
+ *
+ * @return The Alpha Identifier has been written into Buf.
+ *
+ * Unused octets will be written as 0xff.
+ */
+ writeAlphaIdentifier: function(numOctets, alphaId) {
+ if (numOctets === 0) {
+ return "";
+ }
+
+ // If alphaId is empty or it's of GSM 8 bit.
+ if (!alphaId || this.context.ICCUtilsHelper.isGsm8BitAlphabet(alphaId)) {
+ return this.writeStringTo8BitUnpacked(numOctets, alphaId);
+ } else {
+ return this.writeICCUCS2String(numOctets, alphaId);
+ }
+ },
+
+ /**
+ * Read Dialling number.
+ *
+ * @see TS 131.102
+ *
+ * @param len
+ * The Length of BCD number.
+ *
+ * From TS 131.102, in EF_ADN, EF_FDN, the field 'Length of BCD number'
+ * means the total bytes should be allocated to store the TON/NPI and
+ * the dialing number.
+ * For example, if the dialing number is 1234567890,
+ * and the TON/NPI is 0x81,
+ * The field 'Length of BCD number' should be 06, which is
+ * 1 byte to store the TON/NPI, 0x81
+ * 5 bytes to store the BCD number 2143658709.
+ *
+ * Here the definition of the length is different from SMS spec,
+ * TS 23.040 9.1.2.5, which the length means
+ * "number of useful semi-octets within the Address-Value field".
+ */
+ readDiallingNumber: function(len) {
+ if (DEBUG) this.context.debug("PDU: Going to read Dialling number: " + len);
+ if (len === 0) {
+ return "";
+ }
+
+ let GsmPDUHelper = this.context.GsmPDUHelper;
+
+ // TOA = TON + NPI
+ let toa = GsmPDUHelper.readHexOctet();
+
+ let number = GsmPDUHelper.readSwappedNibbleExtendedBcdString(len - 1);
+ if (number.length <= 0) {
+ if (DEBUG) this.context.debug("No number provided");
+ return "";
+ }
+ if ((toa >> 4) == (PDU_TOA_INTERNATIONAL >> 4)) {
+ number = '+' + number;
+ }
+ return number;
+ },
+
+ /**
+ * Write Dialling Number.
+ *
+ * @param number The Dialling number
+ */
+ writeDiallingNumber: function(number) {
+ let GsmPDUHelper = this.context.GsmPDUHelper;
+
+ let toa = PDU_TOA_ISDN; // 81
+ if (number[0] == '+') {
+ toa = PDU_TOA_INTERNATIONAL | PDU_TOA_ISDN; // 91
+ number = number.substring(1);
+ }
+ GsmPDUHelper.writeHexOctet(toa);
+ GsmPDUHelper.writeSwappedNibbleBCD(number);
+ },
+
+ readNumberWithLength: function() {
+ let Buf = this.context.Buf;
+ let number = "";
+ let numLen = this.context.GsmPDUHelper.readHexOctet();
+ if (numLen != 0xff) {
+ if (numLen > ADN_MAX_BCD_NUMBER_BYTES) {
+ if (DEBUG) {
+ this.context.debug(
+ "Error: invalid length of BCD number/SSC contents - " + numLen);
+ }
+ Buf.seekIncoming(ADN_MAX_BCD_NUMBER_BYTES * Buf.PDU_HEX_OCTET_SIZE);
+ return number;
+ }
+
+ number = this.readDiallingNumber(numLen);
+ Buf.seekIncoming((ADN_MAX_BCD_NUMBER_BYTES - numLen) * Buf.PDU_HEX_OCTET_SIZE);
+ } else {
+ Buf.seekIncoming(ADN_MAX_BCD_NUMBER_BYTES * Buf.PDU_HEX_OCTET_SIZE);
+ }
+
+ return number;
+ },
+
+ /**
+ * Write Number with Length
+ *
+ * @param number The value to be written.
+ *
+ * @return The number has been written into Buf.
+ */
+ writeNumberWithLength: function(number) {
+ let GsmPDUHelper = this.context.GsmPDUHelper;
+
+ if (number) {
+ let numStart = number[0] == "+" ? 1 : 0;
+ let writtenNumber = number.substring(0, numStart) +
+ number.substring(numStart)
+ .replace(/[^0-9*#,]/g, "");
+ let numDigits = writtenNumber.length - numStart;
+
+ if (numDigits > ADN_MAX_NUMBER_DIGITS) {
+ writtenNumber = writtenNumber.substring(0, ADN_MAX_NUMBER_DIGITS + numStart);
+ numDigits = writtenNumber.length - numStart;
+ }
+
+ // +1 for TON/NPI
+ let numLen = Math.ceil(numDigits / 2) + 1;
+ GsmPDUHelper.writeHexOctet(numLen);
+ this.writeDiallingNumber(writtenNumber.replace(/\*/g, "a")
+ .replace(/\#/g, "b")
+ .replace(/\,/g, "c"));
+ // Write trailing 0xff of Dialling Number.
+ for (let i = 0; i < ADN_MAX_BCD_NUMBER_BYTES - numLen; i++) {
+ GsmPDUHelper.writeHexOctet(0xff);
+ }
+ return writtenNumber;
+ } else {
+ // +1 for numLen
+ for (let i = 0; i < ADN_MAX_BCD_NUMBER_BYTES + 1; i++) {
+ GsmPDUHelper.writeHexOctet(0xff);
+ }
+ return "";
+ }
+ }
+};
+
+function StkCommandParamsFactoryObject(aContext) {
+ this.context = aContext;
+}
+StkCommandParamsFactoryObject.prototype = {
+ context: null,
+
+ createParam: function(cmdDetails, ctlvs, onComplete) {
+ let method = this[cmdDetails.typeOfCommand];
+ if (typeof method != "function") {
+ if (DEBUG) {
+ this.context.debug("Unknown proactive command " +
+ cmdDetails.typeOfCommand.toString(16));
+ }
+ return;
+ }
+ method.call(this, cmdDetails, ctlvs, onComplete);
+ },
+
+ loadIcons: function(iconIdCtlvs, callback) {
+ if (!iconIdCtlvs ||
+ !this.context.ICCUtilsHelper.isICCServiceAvailable("IMG")) {
+ callback(null);
+ return;
+ }
+
+ let onerror = (function() {
+ callback(null);
+ }).bind(this);
+
+ let onsuccess = (function(aIcons) {
+ callback(aIcons);
+ }).bind(this);
+
+ this.context.IconLoader.loadIcons(iconIdCtlvs.map(aCtlv => aCtlv.value.identifier),
+ onsuccess,
+ onerror);
+ },
+
+ appendIconIfNecessary: function(iconIdCtlvs, result, onComplete) {
+ this.loadIcons(iconIdCtlvs, (aIcons) => {
+ if (aIcons) {
+ result.icons = aIcons[0];
+ result.iconSelfExplanatory =
+ iconIdCtlvs[0].value.qualifier == 0 ? true : false;
+ }
+
+ onComplete(result);
+ });
+ },
+
+ /**
+ * Construct a param for Refresh.
+ *
+ * @param cmdDetails
+ * The value object of CommandDetails TLV.
+ * @param ctlvs
+ * The all TLVs in this proactive command.
+ * @param onComplete
+ * Callback to be called when complete.
+ */
+ processRefresh: function(cmdDetails, ctlvs, onComplete) {
+ let refreshType = cmdDetails.commandQualifier;
+ switch (refreshType) {
+ case STK_REFRESH_FILE_CHANGE:
+ case STK_REFRESH_NAA_INIT_AND_FILE_CHANGE:
+ let ctlv = this.context.StkProactiveCmdHelper.searchForTag(
+ COMPREHENSIONTLV_TAG_FILE_LIST, ctlvs);
+ if (ctlv) {
+ let list = ctlv.value.fileList;
+ if (DEBUG) {
+ this.context.debug("Refresh, list = " + list);
+ }
+ this.context.ICCRecordHelper.fetchICCRecords();
+ }
+ break;
+ }
+
+ onComplete(null);
+ },
+
+ /**
+ * Construct a param for Poll Interval.
+ *
+ * @param cmdDetails
+ * The value object of CommandDetails TLV.
+ * @param ctlvs
+ * The all TLVs in this proactive command.
+ * @param onComplete
+ * Callback to be called when complete.
+ */
+ processPollInterval: function(cmdDetails, ctlvs, onComplete) {
+ // Duration is mandatory.
+ let ctlv = this.context.StkProactiveCmdHelper.searchForTag(
+ COMPREHENSIONTLV_TAG_DURATION, ctlvs);
+ if (!ctlv) {
+ this.context.RIL.sendStkTerminalResponse({
+ command: cmdDetails,
+ resultCode: STK_RESULT_REQUIRED_VALUES_MISSING});
+ throw new Error("Stk Poll Interval: Required value missing : Duration");
+ }
+
+ onComplete(ctlv.value);
+ },
+
+ /**
+ * Construct a param for Poll Off.
+ *
+ * @param cmdDetails
+ * The value object of CommandDetails TLV.
+ * @param ctlvs
+ * The all TLVs in this proactive command.
+ * @param onComplete
+ * Callback to be called when complete.
+ */
+ processPollOff: function(cmdDetails, ctlvs, onComplete) {
+ onComplete(null);
+ },
+
+ /**
+ * Construct a param for Set Up Event list.
+ *
+ * @param cmdDetails
+ * The value object of CommandDetails TLV.
+ * @param ctlvs
+ * The all TLVs in this proactive command.
+ * @param onComplete
+ * Callback to be called when complete.
+ */
+ processSetUpEventList: function(cmdDetails, ctlvs, onComplete) {
+ // Event list is mandatory.
+ let ctlv = this.context.StkProactiveCmdHelper.searchForTag(
+ COMPREHENSIONTLV_TAG_EVENT_LIST, ctlvs);
+ if (!ctlv) {
+ this.context.RIL.sendStkTerminalResponse({
+ command: cmdDetails,
+ resultCode: STK_RESULT_REQUIRED_VALUES_MISSING});
+ throw new Error("Stk Event List: Required value missing : Event List");
+ }
+
+ onComplete(ctlv.value || { eventList: null });
+ },
+
+ /**
+ * Construct a param for Setup Menu.
+ *
+ * @param cmdDetails
+ * The value object of CommandDetails TLV.
+ * @param ctlvs
+ * The all TLVs in this proactive command.
+ * @param onComplete
+ * Callback to be called when complete.
+ */
+ processSetupMenu: function(cmdDetails, ctlvs, onComplete) {
+ let StkProactiveCmdHelper = this.context.StkProactiveCmdHelper;
+ let menu = {
+ // Help information available.
+ isHelpAvailable: !!(cmdDetails.commandQualifier & 0x80)
+ };
+
+ let selectedCtlvs = StkProactiveCmdHelper.searchForSelectedTags(ctlvs, [
+ COMPREHENSIONTLV_TAG_ALPHA_ID,
+ COMPREHENSIONTLV_TAG_ITEM,
+ COMPREHENSIONTLV_TAG_ITEM_ID,
+ COMPREHENSIONTLV_TAG_NEXT_ACTION_IND,
+ COMPREHENSIONTLV_TAG_ICON_ID,
+ COMPREHENSIONTLV_TAG_ICON_ID_LIST
+ ]);
+
+ // Alpha identifier is optional.
+ let ctlv = selectedCtlvs.retrieve(COMPREHENSIONTLV_TAG_ALPHA_ID);
+ if (ctlv) {
+ menu.title = ctlv.value.identifier;
+ }
+
+ // Item data object for item 1 is mandatory.
+ let menuCtlvs = selectedCtlvs[COMPREHENSIONTLV_TAG_ITEM];
+ if (!menuCtlvs) {
+ this.context.RIL.sendStkTerminalResponse({
+ command: cmdDetails,
+ resultCode: STK_RESULT_REQUIRED_VALUES_MISSING});
+ throw new Error("Stk Menu: Required value missing : items");
+ }
+ menu.items = menuCtlvs.map(aCtlv => aCtlv.value);
+
+ // Item identifier is optional.
+ ctlv = selectedCtlvs.retrieve(COMPREHENSIONTLV_TAG_ITEM_ID);
+ if (ctlv) {
+ menu.defaultItem = ctlv.value.identifier - 1;
+ }
+
+ // Items next action indicator is optional.
+ ctlv = selectedCtlvs.retrieve(COMPREHENSIONTLV_TAG_NEXT_ACTION_IND);
+ if (ctlv) {
+ menu.nextActionList = ctlv.value;
+ }
+
+ // Icon identifier is optional.
+ let iconIdCtlvs = null;
+ let menuIconCtlv = selectedCtlvs.retrieve(COMPREHENSIONTLV_TAG_ICON_ID);
+ if (menuIconCtlv) {
+ iconIdCtlvs = [menuIconCtlv];
+ }
+
+ // Item icon identifier list is optional.
+ ctlv = selectedCtlvs.retrieve(COMPREHENSIONTLV_TAG_ICON_ID_LIST);
+ if (ctlv) {
+ if (!iconIdCtlvs) {
+ iconIdCtlvs = [];
+ };
+ let iconIdList = ctlv.value;
+ iconIdCtlvs = iconIdCtlvs.concat(iconIdList.identifiers.map((aId) => {
+ return {
+ value: { qualifier: iconIdList.qualifier, identifier: aId }
+ };
+ }));
+ }
+
+ this.loadIcons(iconIdCtlvs, (aIcons) => {
+ if (aIcons) {
+ if (menuIconCtlv) {
+ menu.iconSelfExplanatory =
+ (iconIdCtlvs.shift().value.qualifier == 0) ? true: false;
+ menu.icons = aIcons.shift();
+ }
+
+ for (let i = 0; i < aIcons.length; i++) {
+ menu.items[i].icons = aIcons[i];
+ menu.items[i].iconSelfExplanatory =
+ (iconIdCtlvs[i].value.qualifier == 0) ? true: false;
+ }
+ }
+
+ onComplete(menu);
+ });
+ },
+
+ /**
+ * Construct a param for Select Item.
+ *
+ * @param cmdDetails
+ * The value object of CommandDetails TLV.
+ * @param ctlvs
+ * The all TLVs in this proactive command.
+ * @param onComplete
+ * Callback to be called when complete.
+ */
+ processSelectItem: function(cmdDetails, ctlvs, onComplete) {
+ this.processSetupMenu(cmdDetails, ctlvs, (menu) => {
+ // The 1st bit and 2nd bit determines the presentation type.
+ menu.presentationType = cmdDetails.commandQualifier & 0x03;
+ onComplete(menu);
+ });
+ },
+
+ /**
+ * Construct a param for Display Text.
+ *
+ * @param cmdDetails
+ * The value object of CommandDetails TLV.
+ * @param ctlvs
+ * The all TLVs in this proactive command.
+ * @param onComplete
+ * Callback to be called when complete.
+ */
+ processDisplayText: function(cmdDetails, ctlvs, onComplete) {
+ let StkProactiveCmdHelper = this.context.StkProactiveCmdHelper;
+ let textMsg = {
+ isHighPriority: !!(cmdDetails.commandQualifier & 0x01),
+ userClear: !!(cmdDetails.commandQualifier & 0x80)
+ };
+
+ let selectedCtlvs = StkProactiveCmdHelper.searchForSelectedTags(ctlvs, [
+ COMPREHENSIONTLV_TAG_TEXT_STRING,
+ COMPREHENSIONTLV_TAG_IMMEDIATE_RESPONSE,
+ COMPREHENSIONTLV_TAG_DURATION,
+ COMPREHENSIONTLV_TAG_ICON_ID
+ ]);
+
+ // Text string is mandatory.
+ let ctlv = selectedCtlvs.retrieve(COMPREHENSIONTLV_TAG_TEXT_STRING);
+ if (!ctlv) {
+ this.context.RIL.sendStkTerminalResponse({
+ command: cmdDetails,
+ resultCode: STK_RESULT_REQUIRED_VALUES_MISSING});
+ throw new Error("Stk Display Text: Required value missing : Text String");
+ }
+ textMsg.text = ctlv.value.textString;
+
+ // Immediate response is optional.
+ textMsg.responseNeeded =
+ !!(selectedCtlvs.retrieve(COMPREHENSIONTLV_TAG_IMMEDIATE_RESPONSE));
+
+ // Duration is optional.
+ ctlv = selectedCtlvs.retrieve(COMPREHENSIONTLV_TAG_DURATION);
+ if (ctlv) {
+ textMsg.duration = ctlv.value;
+ }
+
+ // Icon identifier is optional.
+ this.appendIconIfNecessary(selectedCtlvs[COMPREHENSIONTLV_TAG_ICON_ID] || null,
+ textMsg,
+ onComplete);
+ },
+
+ /**
+ * Construct a param for Setup Idle Mode Text.
+ *
+ * @param cmdDetails
+ * The value object of CommandDetails TLV.
+ * @param ctlvs
+ * The all TLVs in this proactive command.
+ * @param onComplete
+ * Callback to be called when complete.
+ */
+ processSetUpIdleModeText: function(cmdDetails, ctlvs, onComplete) {
+ let StkProactiveCmdHelper = this.context.StkProactiveCmdHelper;
+ let textMsg = {};
+
+ let selectedCtlvs = StkProactiveCmdHelper.searchForSelectedTags(ctlvs, [
+ COMPREHENSIONTLV_TAG_TEXT_STRING,
+ COMPREHENSIONTLV_TAG_ICON_ID
+ ]);
+
+ // Text string is mandatory.
+ let ctlv = selectedCtlvs.retrieve(COMPREHENSIONTLV_TAG_TEXT_STRING);
+ if (!ctlv) {
+ this.context.RIL.sendStkTerminalResponse({
+ command: cmdDetails,
+ resultCode: STK_RESULT_REQUIRED_VALUES_MISSING});
+ throw new Error("Stk Set Up Idle Text: Required value missing : Text String");
+ }
+ textMsg.text = ctlv.value.textString;
+
+ // Icon identifier is optional.
+ this.appendIconIfNecessary(selectedCtlvs[COMPREHENSIONTLV_TAG_ICON_ID] || null,
+ textMsg,
+ onComplete);
+ },
+
+ /**
+ * Construct a param for Get Inkey.
+ *
+ * @param cmdDetails
+ * The value object of CommandDetails TLV.
+ * @param ctlvs
+ * The all TLVs in this proactive command.
+ * @param onComplete
+ * Callback to be called when complete.
+ */
+ processGetInkey: function(cmdDetails, ctlvs, onComplete) {
+ let StkProactiveCmdHelper = this.context.StkProactiveCmdHelper;
+ let input = {
+ minLength: 1,
+ maxLength: 1,
+ isAlphabet: !!(cmdDetails.commandQualifier & 0x01),
+ isUCS2: !!(cmdDetails.commandQualifier & 0x02),
+ // Character sets defined in bit 1 and bit 2 are disable and
+ // the YES/NO reponse is required.
+ isYesNoRequested: !!(cmdDetails.commandQualifier & 0x04),
+ // Help information available.
+ isHelpAvailable: !!(cmdDetails.commandQualifier & 0x80)
+ };
+
+ let selectedCtlvs = StkProactiveCmdHelper.searchForSelectedTags(ctlvs, [
+ COMPREHENSIONTLV_TAG_TEXT_STRING,
+ COMPREHENSIONTLV_TAG_DURATION,
+ COMPREHENSIONTLV_TAG_ICON_ID
+ ]);
+
+ // Text string is mandatory.
+ let ctlv = selectedCtlvs.retrieve(COMPREHENSIONTLV_TAG_TEXT_STRING);
+ if (!ctlv) {
+ this.context.RIL.sendStkTerminalResponse({
+ command: cmdDetails,
+ resultCode: STK_RESULT_REQUIRED_VALUES_MISSING});
+ throw new Error("Stk Get InKey: Required value missing : Text String");
+ }
+ input.text = ctlv.value.textString;
+
+ // Duration is optional.
+ ctlv = selectedCtlvs.retrieve(COMPREHENSIONTLV_TAG_DURATION);
+ if (ctlv) {
+ input.duration = ctlv.value;
+ }
+
+ // Icon identifier is optional.
+ this.appendIconIfNecessary(selectedCtlvs[COMPREHENSIONTLV_TAG_ICON_ID] || null,
+ input,
+ onComplete);
+ },
+
+ /**
+ * Construct a param for Get Input.
+ *
+ * @param cmdDetails
+ * The value object of CommandDetails TLV.
+ * @param ctlvs
+ * The all TLVs in this proactive command.
+ * @param onComplete
+ * Callback to be called when complete.
+ */
+ processGetInput: function(cmdDetails, ctlvs, onComplete) {
+ let StkProactiveCmdHelper = this.context.StkProactiveCmdHelper;
+ let input = {
+ isAlphabet: !!(cmdDetails.commandQualifier & 0x01),
+ isUCS2: !!(cmdDetails.commandQualifier & 0x02),
+ // User input shall not be revealed
+ hideInput: !!(cmdDetails.commandQualifier & 0x04),
+ // User input in SMS packed format
+ isPacked: !!(cmdDetails.commandQualifier & 0x08),
+ // Help information available.
+ isHelpAvailable: !!(cmdDetails.commandQualifier & 0x80)
+ };
+
+ let selectedCtlvs = StkProactiveCmdHelper.searchForSelectedTags(ctlvs, [
+ COMPREHENSIONTLV_TAG_TEXT_STRING,
+ COMPREHENSIONTLV_TAG_RESPONSE_LENGTH,
+ COMPREHENSIONTLV_TAG_DEFAULT_TEXT,
+ COMPREHENSIONTLV_TAG_ICON_ID
+ ]);
+
+ // Text string is mandatory.
+ let ctlv = selectedCtlvs.retrieve(COMPREHENSIONTLV_TAG_TEXT_STRING);
+ if (!ctlv) {
+ this.context.RIL.sendStkTerminalResponse({
+ command: cmdDetails,
+ resultCode: STK_RESULT_REQUIRED_VALUES_MISSING});
+ throw new Error("Stk Get Input: Required value missing : Text String");
+ }
+ input.text = ctlv.value.textString;
+
+ // Response length is mandatory.
+ ctlv = selectedCtlvs.retrieve(COMPREHENSIONTLV_TAG_RESPONSE_LENGTH);
+ if (!ctlv) {
+ this.context.RIL.sendStkTerminalResponse({
+ command: cmdDetails,
+ resultCode: STK_RESULT_REQUIRED_VALUES_MISSING});
+ throw new Error("Stk Get Input: Required value missing : Response Length");
+ }
+ input.minLength = ctlv.value.minLength;
+ input.maxLength = ctlv.value.maxLength;
+
+ // Default text is optional.
+ ctlv = selectedCtlvs.retrieve(COMPREHENSIONTLV_TAG_DEFAULT_TEXT);
+ if (ctlv) {
+ input.defaultText = ctlv.value.textString;
+ }
+
+ // Icon identifier is optional.
+ this.appendIconIfNecessary(selectedCtlvs[COMPREHENSIONTLV_TAG_ICON_ID] || null,
+ input,
+ onComplete);
+ },
+
+ /**
+ * Construct a param for SendSS/SMS/USSD/DTMF.
+ *
+ * @param cmdDetails
+ * The value object of CommandDetails TLV.
+ * @param ctlvs
+ * The all TLVs in this proactive command.
+ * @param onComplete
+ * Callback to be called when complete.
+ */
+ processEventNotify: function(cmdDetails, ctlvs, onComplete) {
+ let StkProactiveCmdHelper = this.context.StkProactiveCmdHelper;
+ let textMsg = {};
+
+ let selectedCtlvs = StkProactiveCmdHelper.searchForSelectedTags(ctlvs, [
+ COMPREHENSIONTLV_TAG_ALPHA_ID,
+ COMPREHENSIONTLV_TAG_ICON_ID
+ ]);
+
+ // Alpha identifier is optional.
+ let ctlv = selectedCtlvs.retrieve(COMPREHENSIONTLV_TAG_ALPHA_ID);
+ if (ctlv) {
+ textMsg.text = ctlv.value.identifier;
+ }
+
+ // According to section 6.4.10 of |ETSI TS 102 223|:
+ //
+ // - if the alpha identifier is provided by the UICC and is a null data
+ // object (i.e. length = '00' and no value part), this is an indication
+ // that the terminal should not give any information to the user on the
+ // fact that the terminal is sending a short message;
+ //
+ // - if the alpha identifier is not provided by the UICC, the terminal may
+ // give information to the user concerning what is happening.
+ //
+ // ICCPDUHelper reads alpha id as an empty string if the length is zero,
+ // hence we'll notify the caller when it's not an empty string.
+ if (textMsg.text !== "") {
+ // Icon identifier is optional.
+ this.appendIconIfNecessary(selectedCtlvs[COMPREHENSIONTLV_TAG_ICON_ID] || null,
+ textMsg,
+ onComplete);
+ }
+ },
+
+ /**
+ * Construct a param for Setup Call.
+ *
+ * @param cmdDetails
+ * The value object of CommandDetails TLV.
+ * @param ctlvs
+ * The all TLVs in this proactive command.
+ * @param onComplete
+ * Callback to be called when complete.
+ */
+ processSetupCall: function(cmdDetails, ctlvs, onComplete) {
+ let StkProactiveCmdHelper = this.context.StkProactiveCmdHelper;
+ let call = {};
+ let confirmMessage = {};
+ let callMessage = {};
+
+ let selectedCtlvs = StkProactiveCmdHelper.searchForSelectedTags(ctlvs, [
+ COMPREHENSIONTLV_TAG_ADDRESS,
+ COMPREHENSIONTLV_TAG_ALPHA_ID,
+ COMPREHENSIONTLV_TAG_ICON_ID,
+ COMPREHENSIONTLV_TAG_DURATION
+ ]);
+
+ // Address is mandatory.
+ let ctlv = selectedCtlvs.retrieve(COMPREHENSIONTLV_TAG_ADDRESS);
+ if (!ctlv) {
+ this.context.RIL.sendStkTerminalResponse({
+ command: cmdDetails,
+ resultCode: STK_RESULT_REQUIRED_VALUES_MISSING});
+ throw new Error("Stk Set Up Call: Required value missing : Address");
+ }
+ call.address = ctlv.value.number;
+
+ // Alpha identifier (user confirmation phase) is optional.
+ ctlv = selectedCtlvs.retrieve(COMPREHENSIONTLV_TAG_ALPHA_ID);
+ if (ctlv) {
+ confirmMessage.text = ctlv.value.identifier;
+ call.confirmMessage = confirmMessage;
+ }
+
+ // Alpha identifier (call set up phase) is optional.
+ ctlv = selectedCtlvs.retrieve(COMPREHENSIONTLV_TAG_ALPHA_ID);
+ if (ctlv) {
+ callMessage.text = ctlv.value.identifier;
+ call.callMessage = callMessage;
+ }
+
+ // Duration is optional.
+ ctlv = selectedCtlvs.retrieve(COMPREHENSIONTLV_TAG_DURATION);
+ if (ctlv) {
+ call.duration = ctlv.value;
+ }
+
+ // Icon identifier is optional.
+ let iconIdCtlvs = selectedCtlvs[COMPREHENSIONTLV_TAG_ICON_ID] || null;
+ this.loadIcons(iconIdCtlvs, (aIcons) => {
+ if (aIcons) {
+ confirmMessage.icons = aIcons[0];
+ confirmMessage.iconSelfExplanatory =
+ (iconIdCtlvs[0].value.qualifier == 0) ? true: false;
+ call.confirmMessage = confirmMessage;
+
+ if (aIcons.length > 1) {
+ callMessage.icons = aIcons[1];
+ callMessage.iconSelfExplanatory =
+ (iconIdCtlvs[1].value.qualifier == 0) ? true: false;
+ call.callMessage = callMessage;
+ }
+ }
+
+ onComplete(call);
+ });
+ },
+
+ /**
+ * Construct a param for Launch Browser.
+ *
+ * @param cmdDetails
+ * The value object of CommandDetails TLV.
+ * @param ctlvs
+ * The all TLVs in this proactive command.
+ * @param onComplete
+ * Callback to be called when complete.
+ */
+ processLaunchBrowser: function(cmdDetails, ctlvs, onComplete) {
+ let StkProactiveCmdHelper = this.context.StkProactiveCmdHelper;
+ let browser = {
+ mode: cmdDetails.commandQualifier & 0x03
+ };
+ let confirmMessage = {};
+
+ let selectedCtlvs = StkProactiveCmdHelper.searchForSelectedTags(ctlvs, [
+ COMPREHENSIONTLV_TAG_URL,
+ COMPREHENSIONTLV_TAG_ALPHA_ID,
+ COMPREHENSIONTLV_TAG_ICON_ID
+ ]);
+
+ // URL is mandatory.
+ let ctlv = selectedCtlvs.retrieve(COMPREHENSIONTLV_TAG_URL);
+ if (!ctlv) {
+ this.context.RIL.sendStkTerminalResponse({
+ command: cmdDetails,
+ resultCode: STK_RESULT_REQUIRED_VALUES_MISSING});
+ throw new Error("Stk Launch Browser: Required value missing : URL");
+ }
+ browser.url = ctlv.value.url;
+
+ // Alpha identifier is optional.
+ ctlv = selectedCtlvs.retrieve(COMPREHENSIONTLV_TAG_ALPHA_ID);
+ if (ctlv) {
+ confirmMessage.text = ctlv.value.identifier;
+ browser.confirmMessage = confirmMessage;
+ }
+
+ // Icon identifier is optional.
+ let iconIdCtlvs = selectedCtlvs[COMPREHENSIONTLV_TAG_ICON_ID] || null;
+ this.loadIcons(iconIdCtlvs, (aIcons) => {
+ if (aIcons) {
+ confirmMessage.icons = aIcons[0];
+ confirmMessage.iconSelfExplanatory =
+ (iconIdCtlvs[0].value.qualifier == 0) ? true: false;
+ browser.confirmMessage = confirmMessage;
+ }
+
+ onComplete(browser);
+ });
+ },
+
+ /**
+ * Construct a param for Play Tone.
+ *
+ * @param cmdDetails
+ * The value object of CommandDetails TLV.
+ * @param ctlvs
+ * The all TLVs in this proactive command.
+ * @param onComplete
+ * Callback to be called when complete.
+ */
+ processPlayTone: function(cmdDetails, ctlvs, onComplete) {
+ let StkProactiveCmdHelper = this.context.StkProactiveCmdHelper;
+ let playTone = {
+ // The vibrate is only defined in TS 102.223.
+ isVibrate: !!(cmdDetails.commandQualifier & 0x01)
+ };
+
+ let selectedCtlvs = StkProactiveCmdHelper.searchForSelectedTags(ctlvs, [
+ COMPREHENSIONTLV_TAG_ALPHA_ID,
+ COMPREHENSIONTLV_TAG_TONE,
+ COMPREHENSIONTLV_TAG_DURATION,
+ COMPREHENSIONTLV_TAG_ICON_ID
+ ]);
+
+ // Alpha identifier is optional.
+ let ctlv = selectedCtlvs.retrieve(COMPREHENSIONTLV_TAG_ALPHA_ID);
+ if (ctlv) {
+ playTone.text = ctlv.value.identifier;
+ }
+
+ // Tone is optional.
+ ctlv = selectedCtlvs.retrieve(COMPREHENSIONTLV_TAG_TONE);
+ if (ctlv) {
+ playTone.tone = ctlv.value.tone;
+ }
+
+ // Duration is optional.
+ ctlv = selectedCtlvs.retrieve(COMPREHENSIONTLV_TAG_DURATION);
+ if (ctlv) {
+ playTone.duration = ctlv.value;
+ }
+
+ // Icon identifier is optional.
+ this.appendIconIfNecessary(selectedCtlvs[COMPREHENSIONTLV_TAG_ICON_ID] || null,
+ playTone,
+ onComplete);
+ },
+
+ /**
+ * Construct a param for Provide Local Information.
+ *
+ * @param cmdDetails
+ * The value object of CommandDetails TLV.
+ * @param ctlvs
+ * The all TLVs in this proactive command.
+ * @param onComplete
+ * Callback to be called when complete.
+ */
+ processProvideLocalInfo: function(cmdDetails, ctlvs, onComplete) {
+ let provideLocalInfo = {
+ localInfoType: cmdDetails.commandQualifier
+ };
+
+ onComplete(provideLocalInfo);
+ },
+
+ /**
+ * Construct a param for Timer Management.
+ *
+ * @param cmdDetails
+ * The value object of CommandDetails TLV.
+ * @param ctlvs
+ * The all TLVs in this proactive command.
+ * @param onComplete
+ * Callback to be called when complete.
+ */
+ processTimerManagement: function(cmdDetails, ctlvs, onComplete) {
+ let StkProactiveCmdHelper = this.context.StkProactiveCmdHelper;
+ let timer = {
+ timerAction: cmdDetails.commandQualifier
+ };
+
+ let selectedCtlvs = StkProactiveCmdHelper.searchForSelectedTags(ctlvs, [
+ COMPREHENSIONTLV_TAG_TIMER_IDENTIFIER,
+ COMPREHENSIONTLV_TAG_TIMER_VALUE
+ ]);
+
+ // Timer identifier is mandatory.
+ let ctlv = selectedCtlvs.retrieve(COMPREHENSIONTLV_TAG_TIMER_IDENTIFIER);
+ if (!ctlv) {
+ this.context.RIL.sendStkTerminalResponse({
+ command: cmdDetails,
+ resultCode: STK_RESULT_REQUIRED_VALUES_MISSING});
+ throw new Error("Stk Timer Management: Required value missing : Timer Identifier");
+ }
+ timer.timerId = ctlv.value.timerId;
+
+ // Timer value is conditional.
+ ctlv = selectedCtlvs.retrieve(COMPREHENSIONTLV_TAG_TIMER_VALUE);
+ if (ctlv) {
+ timer.timerValue = ctlv.value.timerValue;
+ }
+
+ onComplete(timer);
+ },
+
+ /**
+ * Construct a param for BIP commands.
+ *
+ * @param cmdDetails
+ * The value object of CommandDetails TLV.
+ * @param ctlvs
+ * The all TLVs in this proactive command.
+ * @param onComplete
+ * Callback to be called when complete.
+ */
+ processBipMessage: function(cmdDetails, ctlvs, onComplete) {
+ let StkProactiveCmdHelper = this.context.StkProactiveCmdHelper;
+ let bipMsg = {};
+
+ let selectedCtlvs = StkProactiveCmdHelper.searchForSelectedTags(ctlvs, [
+ COMPREHENSIONTLV_TAG_ALPHA_ID,
+ COMPREHENSIONTLV_TAG_ICON_ID
+ ]);
+
+ // Alpha identifier is optional.
+ let ctlv = selectedCtlvs.retrieve(COMPREHENSIONTLV_TAG_ALPHA_ID);
+ if (ctlv) {
+ bipMsg.text = ctlv.value.identifier;
+ }
+
+ // Icon identifier is optional.
+ this.appendIconIfNecessary(selectedCtlvs[COMPREHENSIONTLV_TAG_ICON_ID] || null,
+ bipMsg,
+ onComplete);
+ }
+};
+StkCommandParamsFactoryObject.prototype[STK_CMD_REFRESH] = function STK_CMD_REFRESH(cmdDetails, ctlvs, onComplete) {
+ return this.processRefresh(cmdDetails, ctlvs, onComplete);
+};
+StkCommandParamsFactoryObject.prototype[STK_CMD_POLL_INTERVAL] = function STK_CMD_POLL_INTERVAL(cmdDetails, ctlvs, onComplete) {
+ return this.processPollInterval(cmdDetails, ctlvs, onComplete);
+};
+StkCommandParamsFactoryObject.prototype[STK_CMD_POLL_OFF] = function STK_CMD_POLL_OFF(cmdDetails, ctlvs, onComplete) {
+ return this.processPollOff(cmdDetails, ctlvs, onComplete);
+};
+StkCommandParamsFactoryObject.prototype[STK_CMD_PROVIDE_LOCAL_INFO] = function STK_CMD_PROVIDE_LOCAL_INFO(cmdDetails, ctlvs, onComplete) {
+ return this.processProvideLocalInfo(cmdDetails, ctlvs, onComplete);
+};
+StkCommandParamsFactoryObject.prototype[STK_CMD_SET_UP_EVENT_LIST] = function STK_CMD_SET_UP_EVENT_LIST(cmdDetails, ctlvs, onComplete) {
+ return this.processSetUpEventList(cmdDetails, ctlvs, onComplete);
+};
+StkCommandParamsFactoryObject.prototype[STK_CMD_SET_UP_MENU] = function STK_CMD_SET_UP_MENU(cmdDetails, ctlvs, onComplete) {
+ return this.processSetupMenu(cmdDetails, ctlvs, onComplete);
+};
+StkCommandParamsFactoryObject.prototype[STK_CMD_SELECT_ITEM] = function STK_CMD_SELECT_ITEM(cmdDetails, ctlvs, onComplete) {
+ return this.processSelectItem(cmdDetails, ctlvs, onComplete);
+};
+StkCommandParamsFactoryObject.prototype[STK_CMD_DISPLAY_TEXT] = function STK_CMD_DISPLAY_TEXT(cmdDetails, ctlvs, onComplete) {
+ return this.processDisplayText(cmdDetails, ctlvs, onComplete);
+};
+StkCommandParamsFactoryObject.prototype[STK_CMD_SET_UP_IDLE_MODE_TEXT] = function STK_CMD_SET_UP_IDLE_MODE_TEXT(cmdDetails, ctlvs, onComplete) {
+ return this.processSetUpIdleModeText(cmdDetails, ctlvs, onComplete);
+};
+StkCommandParamsFactoryObject.prototype[STK_CMD_GET_INKEY] = function STK_CMD_GET_INKEY(cmdDetails, ctlvs, onComplete) {
+ return this.processGetInkey(cmdDetails, ctlvs, onComplete);
+};
+StkCommandParamsFactoryObject.prototype[STK_CMD_GET_INPUT] = function STK_CMD_GET_INPUT(cmdDetails, ctlvs, onComplete) {
+ return this.processGetInput(cmdDetails, ctlvs, onComplete);
+};
+StkCommandParamsFactoryObject.prototype[STK_CMD_SEND_SS] = function STK_CMD_SEND_SS(cmdDetails, ctlvs, onComplete) {
+ return this.processEventNotify(cmdDetails, ctlvs, onComplete);
+};
+StkCommandParamsFactoryObject.prototype[STK_CMD_SEND_USSD] = function STK_CMD_SEND_USSD(cmdDetails, ctlvs, onComplete) {
+ return this.processEventNotify(cmdDetails, ctlvs, onComplete);
+};
+StkCommandParamsFactoryObject.prototype[STK_CMD_SEND_SMS] = function STK_CMD_SEND_SMS(cmdDetails, ctlvs, onComplete) {
+ return this.processEventNotify(cmdDetails, ctlvs, onComplete);
+};
+StkCommandParamsFactoryObject.prototype[STK_CMD_SEND_DTMF] = function STK_CMD_SEND_DTMF(cmdDetails, ctlvs, onComplete) {
+ return this.processEventNotify(cmdDetails, ctlvs, onComplete);
+};
+StkCommandParamsFactoryObject.prototype[STK_CMD_SET_UP_CALL] = function STK_CMD_SET_UP_CALL(cmdDetails, ctlvs, onComplete) {
+ return this.processSetupCall(cmdDetails, ctlvs, onComplete);
+};
+StkCommandParamsFactoryObject.prototype[STK_CMD_LAUNCH_BROWSER] = function STK_CMD_LAUNCH_BROWSER(cmdDetails, ctlvs, onComplete) {
+ return this.processLaunchBrowser(cmdDetails, ctlvs, onComplete);
+};
+StkCommandParamsFactoryObject.prototype[STK_CMD_PLAY_TONE] = function STK_CMD_PLAY_TONE(cmdDetails, ctlvs, onComplete) {
+ return this.processPlayTone(cmdDetails, ctlvs, onComplete);
+};
+StkCommandParamsFactoryObject.prototype[STK_CMD_TIMER_MANAGEMENT] = function STK_CMD_TIMER_MANAGEMENT(cmdDetails, ctlvs, onComplete) {
+ return this.processTimerManagement(cmdDetails, ctlvs, onComplete);
+};
+StkCommandParamsFactoryObject.prototype[STK_CMD_OPEN_CHANNEL] = function STK_CMD_OPEN_CHANNEL(cmdDetails, ctlvs, onComplete) {
+ return this.processBipMessage(cmdDetails, ctlvs, onComplete);
+};
+StkCommandParamsFactoryObject.prototype[STK_CMD_CLOSE_CHANNEL] = function STK_CMD_CLOSE_CHANNEL(cmdDetails, ctlvs, onComplete) {
+ return this.processBipMessage(cmdDetails, ctlvs, onComplete);
+};
+StkCommandParamsFactoryObject.prototype[STK_CMD_RECEIVE_DATA] = function STK_CMD_RECEIVE_DATA(cmdDetails, ctlvs, onComplete) {
+ return this.processBipMessage(cmdDetails, ctlvs, onComplete);
+};
+StkCommandParamsFactoryObject.prototype[STK_CMD_SEND_DATA] = function STK_CMD_SEND_DATA(cmdDetails, ctlvs, onComplete) {
+ return this.processBipMessage(cmdDetails, ctlvs, onComplete);
+};
+
+function StkProactiveCmdHelperObject(aContext) {
+ this.context = aContext;
+}
+StkProactiveCmdHelperObject.prototype = {
+ context: null,
+
+ retrieve: function(tag, length) {
+ let method = this[tag];
+ if (typeof method != "function") {
+ if (DEBUG) {
+ this.context.debug("Unknown comprehension tag " + tag.toString(16));
+ }
+ let Buf = this.context.Buf;
+ Buf.seekIncoming(length * Buf.PDU_HEX_OCTET_SIZE);
+ return null;
+ }
+ return method.call(this, length);
+ },
+
+ /**
+ * Command Details.
+ *
+ * | Byte | Description | Length |
+ * | 1 | Command details Tag | 1 |
+ * | 2 | Length = 03 | 1 |
+ * | 3 | Command number | 1 |
+ * | 4 | Type of Command | 1 |
+ * | 5 | Command Qualifier | 1 |
+ */
+ retrieveCommandDetails: function(length) {
+ let GsmPDUHelper = this.context.GsmPDUHelper;
+ let cmdDetails = {
+ commandNumber: GsmPDUHelper.readHexOctet(),
+ typeOfCommand: GsmPDUHelper.readHexOctet(),
+ commandQualifier: GsmPDUHelper.readHexOctet()
+ };
+ return cmdDetails;
+ },
+
+ /**
+ * Device Identities.
+ *
+ * | Byte | Description | Length |
+ * | 1 | Device Identity Tag | 1 |
+ * | 2 | Length = 02 | 1 |
+ * | 3 | Source device Identity | 1 |
+ * | 4 | Destination device Id | 1 |
+ */
+ retrieveDeviceId: function(length) {
+ let GsmPDUHelper = this.context.GsmPDUHelper;
+ let deviceId = {
+ sourceId: GsmPDUHelper.readHexOctet(),
+ destinationId: GsmPDUHelper.readHexOctet()
+ };
+ return deviceId;
+ },
+
+ /**
+ * Alpha Identifier.
+ *
+ * | Byte | Description | Length |
+ * | 1 | Alpha Identifier Tag | 1 |
+ * | 2 ~ (Y-1)+2 | Length (X) | Y |
+ * | (Y-1)+3 ~ | Alpha identfier | X |
+ * | (Y-1)+X+2 | | |
+ */
+ retrieveAlphaId: function(length) {
+ let alphaId = {
+ identifier: this.context.ICCPDUHelper.readAlphaIdentifier(length)
+ };
+ return alphaId;
+ },
+
+ /**
+ * Duration.
+ *
+ * | Byte | Description | Length |
+ * | 1 | Response Length Tag | 1 |
+ * | 2 | Lenth = 02 | 1 |
+ * | 3 | Time unit | 1 |
+ * | 4 | Time interval | 1 |
+ */
+ retrieveDuration: function(length) {
+ let GsmPDUHelper = this.context.GsmPDUHelper;
+ let duration = {
+ timeUnit: GsmPDUHelper.readHexOctet(),
+ timeInterval: GsmPDUHelper.readHexOctet(),
+ };
+ return duration;
+ },
+
+ /**
+ * Address.
+ *
+ * | Byte | Description | Length |
+ * | 1 | Alpha Identifier Tag | 1 |
+ * | 2 ~ (Y-1)+2 | Length (X) | Y |
+ * | (Y-1)+3 | TON and NPI | 1 |
+ * | (Y-1)+4 ~ | Dialling number | X |
+ * | (Y-1)+X+2 | | |
+ */
+ retrieveAddress: function(length) {
+ let address = {
+ number : this.context.ICCPDUHelper.readDiallingNumber(length)
+ };
+ return address;
+ },
+
+ /**
+ * Text String.
+ *
+ * | Byte | Description | Length |
+ * | 1 | Text String Tag | 1 |
+ * | 2 ~ (Y-1)+2 | Length (X) | Y |
+ * | (Y-1)+3 | Data coding scheme | 1 |
+ * | (Y-1)+4~ | Text String | X |
+ * | (Y-1)+X+2 | | |
+ */
+ retrieveTextString: function(length) {
+ if (!length) {
+ // null string.
+ return {textString: null};
+ }
+
+ let GsmPDUHelper = this.context.GsmPDUHelper;
+ let text = {
+ codingScheme: GsmPDUHelper.readHexOctet()
+ };
+
+ length--; // -1 for the codingScheme.
+ switch (text.codingScheme & 0x0c) {
+ case STK_TEXT_CODING_GSM_7BIT_PACKED:
+ text.textString =
+ GsmPDUHelper.readSeptetsToString(Math.floor(length * 8 / 7), 0, 0, 0);
+ break;
+ case STK_TEXT_CODING_GSM_8BIT:
+ text.textString =
+ this.context.ICCPDUHelper.read8BitUnpackedToString(length);
+ break;
+ case STK_TEXT_CODING_UCS2:
+ text.textString = GsmPDUHelper.readUCS2String(length);
+ break;
+ }
+ return text;
+ },
+
+ /**
+ * Tone.
+ *
+ * | Byte | Description | Length |
+ * | 1 | Tone Tag | 1 |
+ * | 2 | Lenth = 01 | 1 |
+ * | 3 | Tone | 1 |
+ */
+ retrieveTone: function(length) {
+ let tone = {
+ tone: this.context.GsmPDUHelper.readHexOctet(),
+ };
+ return tone;
+ },
+
+ /**
+ * Item.
+ *
+ * | Byte | Description | Length |
+ * | 1 | Item Tag | 1 |
+ * | 2 ~ (Y-1)+2 | Length (X) | Y |
+ * | (Y-1)+3 | Identifier of item | 1 |
+ * | (Y-1)+4 ~ | Text string of item | X |
+ * | (Y-1)+X+2 | | |
+ */
+ retrieveItem: function(length) {
+ // TS 102.223 ,clause 6.6.7 SET-UP MENU
+ // If the "Item data object for item 1" is a null data object
+ // (i.e. length = '00' and no value part), this is an indication to the ME
+ // to remove the existing menu from the menu system in the ME.
+ if (!length) {
+ return null;
+ }
+ let item = {
+ identifier: this.context.GsmPDUHelper.readHexOctet(),
+ text: this.context.ICCPDUHelper.readAlphaIdentifier(length - 1)
+ };
+ return item;
+ },
+
+ /**
+ * Item Identifier.
+ *
+ * | Byte | Description | Length |
+ * | 1 | Item Identifier Tag | 1 |
+ * | 2 | Lenth = 01 | 1 |
+ * | 3 | Identifier of Item chosen | 1 |
+ */
+ retrieveItemId: function(length) {
+ let itemId = {
+ identifier: this.context.GsmPDUHelper.readHexOctet()
+ };
+ return itemId;
+ },
+
+ /**
+ * Response Length.
+ *
+ * | Byte | Description | Length |
+ * | 1 | Response Length Tag | 1 |
+ * | 2 | Lenth = 02 | 1 |
+ * | 3 | Minimum length of response | 1 |
+ * | 4 | Maximum length of response | 1 |
+ */
+ retrieveResponseLength: function(length) {
+ let GsmPDUHelper = this.context.GsmPDUHelper;
+ let rspLength = {
+ minLength : GsmPDUHelper.readHexOctet(),
+ maxLength : GsmPDUHelper.readHexOctet()
+ };
+ return rspLength;
+ },
+
+ /**
+ * File List.
+ *
+ * | Byte | Description | Length |
+ * | 1 | File List Tag | 1 |
+ * | 2 ~ (Y-1)+2 | Length (X) | Y |
+ * | (Y-1)+3 | Number of files | 1 |
+ * | (Y-1)+4 ~ | Files | X |
+ * | (Y-1)+X+2 | | |
+ */
+ retrieveFileList: function(length) {
+ let num = this.context.GsmPDUHelper.readHexOctet();
+ let fileList = "";
+ length--; // -1 for the num octet.
+ for (let i = 0; i < 2 * length; i++) {
+ // Didn't use readHexOctet here,
+ // otherwise 0x00 will be "0", not "00"
+ fileList += String.fromCharCode(this.context.Buf.readUint16());
+ }
+ return {
+ fileList: fileList
+ };
+ },
+
+ /**
+ * Default Text.
+ *
+ * Same as Text String.
+ */
+ retrieveDefaultText: function(length) {
+ return this.retrieveTextString(length);
+ },
+
+ /**
+ * Event List.
+ */
+ retrieveEventList: function(length) {
+ if (!length) {
+ // null means an indication to ME to remove the existing list of events
+ // in ME.
+ return null;
+ }
+
+ let GsmPDUHelper = this.context.GsmPDUHelper;
+ let eventList = [];
+ for (let i = 0; i < length; i++) {
+ eventList.push(GsmPDUHelper.readHexOctet());
+ }
+ return {
+ eventList: eventList
+ };
+ },
+
+ /**
+ * Icon Id.
+ *
+ * | Byte | Description | Length |
+ * | 1 | Icon Identifier Tag | 1 |
+ * | 2 | Length = 02 | 1 |
+ * | 3 | Icon qualifier | 1 |
+ * | 4 | Icon identifier | 1 |
+ */
+ retrieveIconId: function(length) {
+ if (!length) {
+ return null;
+ }
+
+ let iconId = {
+ qualifier: this.context.GsmPDUHelper.readHexOctet(),
+ identifier: this.context.GsmPDUHelper.readHexOctet()
+ };
+ return iconId;
+ },
+
+ /**
+ * Icon Id List.
+ *
+ * | Byte | Description | Length |
+ * | 1 | Icon Identifier Tag | 1 |
+ * | 2 | Length = X | 1 |
+ * | 3 | Icon qualifier | 1 |
+ * | 4~ | Icon identifier | X-1 |
+ * | 4+X-2 | | |
+ */
+ retrieveIconIdList: function(length) {
+ if (!length) {
+ return null;
+ }
+
+ let iconIdList = {
+ qualifier: this.context.GsmPDUHelper.readHexOctet(),
+ identifiers: []
+ };
+ for (let i = 0; i < length - 1; i++) {
+ iconIdList.identifiers.push(this.context.GsmPDUHelper.readHexOctet());
+ }
+ return iconIdList;
+ },
+
+ /**
+ * Timer Identifier.
+ *
+ * | Byte | Description | Length |
+ * | 1 | Timer Identifier Tag | 1 |
+ * | 2 | Length = 01 | 1 |
+ * | 3 | Timer Identifier | 1 |
+ */
+ retrieveTimerId: function(length) {
+ let id = {
+ timerId: this.context.GsmPDUHelper.readHexOctet()
+ };
+ return id;
+ },
+
+ /**
+ * Timer Value.
+ *
+ * | Byte | Description | Length |
+ * | 1 | Timer Value Tag | 1 |
+ * | 2 | Length = 03 | 1 |
+ * | 3 | Hour | 1 |
+ * | 4 | Minute | 1 |
+ * | 5 | Second | 1 |
+ */
+ retrieveTimerValue: function(length) {
+ let GsmPDUHelper = this.context.GsmPDUHelper;
+ let value = {
+ timerValue: (GsmPDUHelper.readSwappedNibbleBcdNum(1) * 60 * 60) +
+ (GsmPDUHelper.readSwappedNibbleBcdNum(1) * 60) +
+ (GsmPDUHelper.readSwappedNibbleBcdNum(1))
+ };
+ return value;
+ },
+
+ /**
+ * Immediate Response.
+ *
+ * | Byte | Description | Length |
+ * | 1 | Immediate Response Tag | 1 |
+ * | 2 | Length = 00 | 1 |
+ */
+ retrieveImmediaResponse: function(length) {
+ return {};
+ },
+
+ /**
+ * URL
+ *
+ * | Byte | Description | Length |
+ * | 1 | URL Tag | 1 |
+ * | 2 ~ (Y+1) | Length(X) | Y |
+ * | (Y+2) ~ | URL | X |
+ * | (Y+1+X) | | |
+ */
+ retrieveUrl: function(length) {
+ let GsmPDUHelper = this.context.GsmPDUHelper;
+ let s = "";
+ for (let i = 0; i < length; i++) {
+ s += String.fromCharCode(GsmPDUHelper.readHexOctet());
+ }
+ return {url: s};
+ },
+
+ /**
+ * Next Action Indicator List.
+ *
+ * | Byte | Description | Length |
+ * | 1 | Next Action tag | 1 |
+ * | 1 | Length(X) | 1 |
+ * | 3~ | Next Action List | X |
+ * | 3+X-1 | | |
+ */
+ retrieveNextActionList: function(length) {
+ let GsmPDUHelper = this.context.GsmPDUHelper;
+ let nextActionList = [];
+ for (let i = 0; i < length; i++) {
+ nextActionList.push(GsmPDUHelper.readHexOctet());
+ }
+ return nextActionList;
+ },
+
+ searchForTag: function(tag, ctlvs) {
+ for (let ctlv of ctlvs) {
+ if ((ctlv.tag & ~COMPREHENSIONTLV_FLAG_CR) == tag) {
+ return ctlv;
+ }
+ }
+ return null;
+ },
+
+ searchForSelectedTags: function(ctlvs, tags) {
+ let ret = {
+ // Handy utility to de-queue the 1st ctlv of the specified tag.
+ retrieve: function(aTag) {
+ return (this[aTag]) ? this[aTag].shift() : null;
+ }
+ };
+
+ ctlvs.forEach((aCtlv) => {
+ tags.forEach((aTag) => {
+ if ((aCtlv.tag & ~COMPREHENSIONTLV_FLAG_CR) == aTag) {
+ if (!ret[aTag]) {
+ ret[aTag] = [];
+ }
+ ret[aTag].push(aCtlv);
+ }
+ });
+ });
+
+ return ret;
+ },
+};
+StkProactiveCmdHelperObject.prototype[COMPREHENSIONTLV_TAG_COMMAND_DETAILS] = function COMPREHENSIONTLV_TAG_COMMAND_DETAILS(length) {
+ return this.retrieveCommandDetails(length);
+};
+StkProactiveCmdHelperObject.prototype[COMPREHENSIONTLV_TAG_DEVICE_ID] = function COMPREHENSIONTLV_TAG_DEVICE_ID(length) {
+ return this.retrieveDeviceId(length);
+};
+StkProactiveCmdHelperObject.prototype[COMPREHENSIONTLV_TAG_ALPHA_ID] = function COMPREHENSIONTLV_TAG_ALPHA_ID(length) {
+ return this.retrieveAlphaId(length);
+};
+StkProactiveCmdHelperObject.prototype[COMPREHENSIONTLV_TAG_DURATION] = function COMPREHENSIONTLV_TAG_DURATION(length) {
+ return this.retrieveDuration(length);
+};
+StkProactiveCmdHelperObject.prototype[COMPREHENSIONTLV_TAG_ADDRESS] = function COMPREHENSIONTLV_TAG_ADDRESS(length) {
+ return this.retrieveAddress(length);
+};
+StkProactiveCmdHelperObject.prototype[COMPREHENSIONTLV_TAG_TEXT_STRING] = function COMPREHENSIONTLV_TAG_TEXT_STRING(length) {
+ return this.retrieveTextString(length);
+};
+StkProactiveCmdHelperObject.prototype[COMPREHENSIONTLV_TAG_TONE] = function COMPREHENSIONTLV_TAG_TONE(length) {
+ return this.retrieveTone(length);
+};
+StkProactiveCmdHelperObject.prototype[COMPREHENSIONTLV_TAG_ITEM] = function COMPREHENSIONTLV_TAG_ITEM(length) {
+ return this.retrieveItem(length);
+};
+StkProactiveCmdHelperObject.prototype[COMPREHENSIONTLV_TAG_ITEM_ID] = function COMPREHENSIONTLV_TAG_ITEM_ID(length) {
+ return this.retrieveItemId(length);
+};
+StkProactiveCmdHelperObject.prototype[COMPREHENSIONTLV_TAG_RESPONSE_LENGTH] = function COMPREHENSIONTLV_TAG_RESPONSE_LENGTH(length) {
+ return this.retrieveResponseLength(length);
+};
+StkProactiveCmdHelperObject.prototype[COMPREHENSIONTLV_TAG_FILE_LIST] = function COMPREHENSIONTLV_TAG_FILE_LIST(length) {
+ return this.retrieveFileList(length);
+};
+StkProactiveCmdHelperObject.prototype[COMPREHENSIONTLV_TAG_DEFAULT_TEXT] = function COMPREHENSIONTLV_TAG_DEFAULT_TEXT(length) {
+ return this.retrieveDefaultText(length);
+};
+StkProactiveCmdHelperObject.prototype[COMPREHENSIONTLV_TAG_EVENT_LIST] = function COMPREHENSIONTLV_TAG_EVENT_LIST(length) {
+ return this.retrieveEventList(length);
+};
+StkProactiveCmdHelperObject.prototype[COMPREHENSIONTLV_TAG_ICON_ID] = function COMPREHENSIONTLV_TAG_ICON_ID(length) {
+ return this.retrieveIconId(length);
+};
+StkProactiveCmdHelperObject.prototype[COMPREHENSIONTLV_TAG_ICON_ID_LIST] = function COMPREHENSIONTLV_TAG_ICON_ID_LIST(length) {
+ return this.retrieveIconIdList(length);
+};
+StkProactiveCmdHelperObject.prototype[COMPREHENSIONTLV_TAG_TIMER_IDENTIFIER] = function COMPREHENSIONTLV_TAG_TIMER_IDENTIFIER(length) {
+ return this.retrieveTimerId(length);
+};
+StkProactiveCmdHelperObject.prototype[COMPREHENSIONTLV_TAG_TIMER_VALUE] = function COMPREHENSIONTLV_TAG_TIMER_VALUE(length) {
+ return this.retrieveTimerValue(length);
+};
+StkProactiveCmdHelperObject.prototype[COMPREHENSIONTLV_TAG_IMMEDIATE_RESPONSE] = function COMPREHENSIONTLV_TAG_IMMEDIATE_RESPONSE(length) {
+ return this.retrieveImmediaResponse(length);
+};
+StkProactiveCmdHelperObject.prototype[COMPREHENSIONTLV_TAG_URL] = function COMPREHENSIONTLV_TAG_URL(length) {
+ return this.retrieveUrl(length);
+};
+StkProactiveCmdHelperObject.prototype[COMPREHENSIONTLV_TAG_NEXT_ACTION_IND] = function COMPREHENSIONTLV_TAG_NEXT_ACTION_IND(length) {
+ return this.retrieveNextActionList(length);
+};
+
+function ComprehensionTlvHelperObject(aContext) {
+ this.context = aContext;
+}
+ComprehensionTlvHelperObject.prototype = {
+ context: null,
+
+ /**
+ * Decode raw data to a Comprehension-TLV.
+ */
+ decode: function() {
+ let GsmPDUHelper = this.context.GsmPDUHelper;
+
+ let hlen = 0; // For header(tag field + length field) length.
+ let temp = GsmPDUHelper.readHexOctet();
+ hlen++;
+
+ // TS 101.220, clause 7.1.1
+ let tag, cr;
+ switch (temp) {
+ // TS 101.220, clause 7.1.1
+ case 0x0: // Not used.
+ case 0xff: // Not used.
+ case 0x80: // Reserved for future use.
+ throw new Error("Invalid octet when parsing Comprehension TLV :" + temp);
+ case 0x7f: // Tag is three byte format.
+ // TS 101.220 clause 7.1.1.2.
+ // | Byte 1 | Byte 2 | Byte 3 |
+ // | | 8 | 7 | 6 | 5 | 4 | 3 | 2 | 1 | |
+ // | 0x7f |CR | Tag Value |
+ tag = (GsmPDUHelper.readHexOctet() << 8) | GsmPDUHelper.readHexOctet();
+ hlen += 2;
+ cr = (tag & 0x8000) !== 0;
+ tag &= ~0x8000;
+ break;
+ default: // Tag is single byte format.
+ tag = temp;
+ // TS 101.220 clause 7.1.1.1.
+ // | 8 | 7 | 6 | 5 | 4 | 3 | 2 | 1 |
+ // |CR | Tag Value |
+ cr = (tag & 0x80) !== 0;
+ tag &= ~0x80;
+ }
+
+ // TS 101.220 clause 7.1.2, Length Encoding.
+ // Length | Byte 1 | Byte 2 | Byte 3 | Byte 4 |
+ // 0 - 127 | 00 - 7f | N/A | N/A | N/A |
+ // 128-255 | 81 | 80 - ff| N/A | N/A |
+ // 256-65535| 82 | 0100 - ffff | N/A |
+ // 65536- | 83 | 010000 - ffffff |
+ // 16777215
+ //
+ // Length errors: TS 11.14, clause 6.10.6
+
+ let length; // Data length.
+ temp = GsmPDUHelper.readHexOctet();
+ hlen++;
+ if (temp < 0x80) {
+ length = temp;
+ } else if (temp == 0x81) {
+ length = GsmPDUHelper.readHexOctet();
+ hlen++;
+ if (length < 0x80) {
+ throw new Error("Invalid length in Comprehension TLV :" + length);
+ }
+ } else if (temp == 0x82) {
+ length = (GsmPDUHelper.readHexOctet() << 8) | GsmPDUHelper.readHexOctet();
+ hlen += 2;
+ if (lenth < 0x0100) {
+ throw new Error("Invalid length in 3-byte Comprehension TLV :" + length);
+ }
+ } else if (temp == 0x83) {
+ length = (GsmPDUHelper.readHexOctet() << 16) |
+ (GsmPDUHelper.readHexOctet() << 8) |
+ GsmPDUHelper.readHexOctet();
+ hlen += 3;
+ if (length < 0x010000) {
+ throw new Error("Invalid length in 4-byte Comprehension TLV :" + length);
+ }
+ } else {
+ throw new Error("Invalid octet in Comprehension TLV :" + temp);
+ }
+
+ let ctlv = {
+ tag: tag,
+ length: length,
+ value: this.context.StkProactiveCmdHelper.retrieve(tag, length),
+ cr: cr,
+ hlen: hlen
+ };
+ return ctlv;
+ },
+
+ decodeChunks: function(length) {
+ let chunks = [];
+ let index = 0;
+ while (index < length) {
+ let tlv = this.decode();
+ chunks.push(tlv);
+ index += tlv.length;
+ index += tlv.hlen;
+ }
+ return chunks;
+ },
+
+ /**
+ * Write Location Info Comprehension TLV.
+ *
+ * @param loc location Information.
+ */
+ writeLocationInfoTlv: function(loc) {
+ let GsmPDUHelper = this.context.GsmPDUHelper;
+
+ GsmPDUHelper.writeHexOctet(COMPREHENSIONTLV_TAG_LOCATION_INFO |
+ COMPREHENSIONTLV_FLAG_CR);
+ GsmPDUHelper.writeHexOctet(loc.gsmCellId > 0xffff ? 9 : 7);
+ // From TS 11.14, clause 12.19
+ // "The mobile country code (MCC), the mobile network code (MNC),
+ // the location area code (LAC) and the cell ID are
+ // coded as in TS 04.08."
+ // And from TS 04.08 and TS 24.008,
+ // the format is as follows:
+ //
+ // MCC = MCC_digit_1 + MCC_digit_2 + MCC_digit_3
+ //
+ // 8 7 6 5 4 3 2 1
+ // +-------------+-------------+
+ // | MCC digit 2 | MCC digit 1 | octet 2
+ // | MNC digit 3 | MCC digit 3 | octet 3
+ // | MNC digit 2 | MNC digit 1 | octet 4
+ // +-------------+-------------+
+ //
+ // Also in TS 24.008
+ // "However a network operator may decide to
+ // use only two digits in the MNC in the LAI over the
+ // radio interface. In this case, bits 5 to 8 of octet 3
+ // shall be coded as '1111'".
+
+ // MCC & MNC, 3 octets
+ let mcc = loc.mcc, mnc;
+ if (loc.mnc.length == 2) {
+ mnc = "F" + loc.mnc;
+ } else {
+ mnc = loc.mnc[2] + loc.mnc[0] + loc.mnc[1];
+ }
+ GsmPDUHelper.writeSwappedNibbleBCD(mcc + mnc);
+
+ // LAC, 2 octets
+ GsmPDUHelper.writeHexOctet((loc.gsmLocationAreaCode >> 8) & 0xff);
+ GsmPDUHelper.writeHexOctet(loc.gsmLocationAreaCode & 0xff);
+
+ // Cell Id
+ if (loc.gsmCellId > 0xffff) {
+ // UMTS/WCDMA, gsmCellId is 28 bits.
+ GsmPDUHelper.writeHexOctet((loc.gsmCellId >> 24) & 0xff);
+ GsmPDUHelper.writeHexOctet((loc.gsmCellId >> 16) & 0xff);
+ GsmPDUHelper.writeHexOctet((loc.gsmCellId >> 8) & 0xff);
+ GsmPDUHelper.writeHexOctet(loc.gsmCellId & 0xff);
+ } else {
+ // GSM, gsmCellId is 16 bits.
+ GsmPDUHelper.writeHexOctet((loc.gsmCellId >> 8) & 0xff);
+ GsmPDUHelper.writeHexOctet(loc.gsmCellId & 0xff);
+ }
+ },
+
+ /**
+ * Given a geckoError string, this function translates it into cause value
+ * and write the value into buffer.
+ *
+ * @param geckoError Error string that is passed to gecko.
+ */
+ writeCauseTlv: function(geckoError) {
+ let GsmPDUHelper = this.context.GsmPDUHelper;
+
+ let cause = -1;
+ for (let errorNo in RIL_CALL_FAILCAUSE_TO_GECKO_CALL_ERROR) {
+ if (geckoError == RIL_CALL_FAILCAUSE_TO_GECKO_CALL_ERROR[errorNo]) {
+ cause = errorNo;
+ break;
+ }
+ }
+
+ // Causes specified in 10.5.4.11 of TS 04.08 are less than 128.
+ // we can ignore causes > 127 since Cause TLV is optional in
+ // STK_EVENT_TYPE_CALL_DISCONNECTED.
+ if (cause > 127) {
+ return;
+ }
+
+ cause = (cause == -1) ? ERROR_SUCCESS : cause;
+
+ GsmPDUHelper.writeHexOctet(COMPREHENSIONTLV_TAG_CAUSE |
+ COMPREHENSIONTLV_FLAG_CR);
+ GsmPDUHelper.writeHexOctet(2); // For single cause value.
+
+ // TS 04.08, clause 10.5.4.11:
+ // Code Standard : Standard defined for GSM PLMNS
+ // Location: User
+ GsmPDUHelper.writeHexOctet(0x60);
+
+ // TS 04.08, clause 10.5.4.11: ext bit = 1 + 7 bits for cause.
+ // +-----------------+----------------------------------+
+ // | Ext = 1 (1 bit) | Cause (7 bits) |
+ // +-----------------+----------------------------------+
+ GsmPDUHelper.writeHexOctet(0x80 | cause);
+ },
+
+ writeDateTimeZoneTlv: function(date) {
+ let GsmPDUHelper = this.context.GsmPDUHelper;
+
+ GsmPDUHelper.writeHexOctet(COMPREHENSIONTLV_TAG_DATE_TIME_ZONE);
+ GsmPDUHelper.writeHexOctet(7);
+ GsmPDUHelper.writeTimestamp(date);
+ },
+
+ writeLanguageTlv: function(language) {
+ let GsmPDUHelper = this.context.GsmPDUHelper;
+
+ GsmPDUHelper.writeHexOctet(COMPREHENSIONTLV_TAG_LANGUAGE);
+ GsmPDUHelper.writeHexOctet(2);
+
+ // ISO 639-1, Alpha-2 code
+ // TS 123.038, clause 6.2.1, GSM 7 bit Default Alphabet
+ GsmPDUHelper.writeHexOctet(
+ PDU_NL_LOCKING_SHIFT_TABLES[PDU_NL_IDENTIFIER_DEFAULT].indexOf(language[0]));
+ GsmPDUHelper.writeHexOctet(
+ PDU_NL_LOCKING_SHIFT_TABLES[PDU_NL_IDENTIFIER_DEFAULT].indexOf(language[1]));
+ },
+
+ /**
+ * Write Timer Value Comprehension TLV.
+ *
+ * @param seconds length of time during of the timer.
+ * @param cr Comprehension Required or not
+ */
+ writeTimerValueTlv: function(seconds, cr) {
+ let GsmPDUHelper = this.context.GsmPDUHelper;
+
+ GsmPDUHelper.writeHexOctet(COMPREHENSIONTLV_TAG_TIMER_VALUE |
+ (cr ? COMPREHENSIONTLV_FLAG_CR : 0));
+ GsmPDUHelper.writeHexOctet(3);
+
+ // TS 102.223, clause 8.38
+ // +----------------+------------------+-------------------+
+ // | hours (1 byte) | minutes (1 btye) | seconds (1 byte) |
+ // +----------------+------------------+-------------------+
+ GsmPDUHelper.writeSwappedNibbleBCDNum(Math.floor(seconds / 60 / 60));
+ GsmPDUHelper.writeSwappedNibbleBCDNum(Math.floor(seconds / 60) % 60);
+ GsmPDUHelper.writeSwappedNibbleBCDNum(Math.floor(seconds) % 60);
+ },
+
+ writeTextStringTlv: function(text, coding) {
+ let GsmPDUHelper = this.context.GsmPDUHelper;
+ let buf = GsmPDUHelper.writeWithBuffer(() => {
+ // Write Coding.
+ GsmPDUHelper.writeHexOctet(coding);
+
+ // Write Text String.
+ switch (coding) {
+ case STK_TEXT_CODING_UCS2:
+ GsmPDUHelper.writeUCS2String(text);
+ break;
+ case STK_TEXT_CODING_GSM_7BIT_PACKED:
+ GsmPDUHelper.writeStringAsSeptets(text, 0, 0, 0);
+ break;
+ case STK_TEXT_CODING_GSM_8BIT:
+ GsmPDUHelper.writeStringAs8BitUnpacked(text);
+ break;
+ }
+ });
+
+ let length = buf.length;
+ if (length) {
+ // Write Tag.
+ GsmPDUHelper.writeHexOctet(COMPREHENSIONTLV_TAG_TEXT_STRING |
+ COMPREHENSIONTLV_FLAG_CR);
+ // Write Length.
+ this.writeLength(length);
+ // Write Value.
+ for (let i = 0; i < length; i++) {
+ GsmPDUHelper.writeHexOctet(buf[i]);
+ }
+ }
+ },
+
+ getSizeOfLengthOctets: function(length) {
+ if (length >= 0x10000) {
+ return 4; // 0x83, len_1, len_2, len_3
+ } else if (length >= 0x100) {
+ return 3; // 0x82, len_1, len_2
+ } else if (length >= 0x80) {
+ return 2; // 0x81, len
+ } else {
+ return 1; // len
+ }
+ },
+
+ writeLength: function(length) {
+ let GsmPDUHelper = this.context.GsmPDUHelper;
+
+ // TS 101.220 clause 7.1.2, Length Encoding.
+ // Length | Byte 1 | Byte 2 | Byte 3 | Byte 4 |
+ // 0 - 127 | 00 - 7f | N/A | N/A | N/A |
+ // 128-255 | 81 | 80 - ff| N/A | N/A |
+ // 256-65535| 82 | 0100 - ffff | N/A |
+ // 65536- | 83 | 010000 - ffffff |
+ // 16777215
+ if (length < 0x80) {
+ GsmPDUHelper.writeHexOctet(length);
+ } else if (0x80 <= length && length < 0x100) {
+ GsmPDUHelper.writeHexOctet(0x81);
+ GsmPDUHelper.writeHexOctet(length);
+ } else if (0x100 <= length && length < 0x10000) {
+ GsmPDUHelper.writeHexOctet(0x82);
+ GsmPDUHelper.writeHexOctet((length >> 8) & 0xff);
+ GsmPDUHelper.writeHexOctet(length & 0xff);
+ } else if (0x10000 <= length && length < 0x1000000) {
+ GsmPDUHelper.writeHexOctet(0x83);
+ GsmPDUHelper.writeHexOctet((length >> 16) & 0xff);
+ GsmPDUHelper.writeHexOctet((length >> 8) & 0xff);
+ GsmPDUHelper.writeHexOctet(length & 0xff);
+ } else {
+ throw new Error("Invalid length value :" + length);
+ }
+ },
+};
+
+function BerTlvHelperObject(aContext) {
+ this.context = aContext;
+}
+BerTlvHelperObject.prototype = {
+ context: null,
+
+ /**
+ * Decode Ber TLV.
+ *
+ * @param dataLen
+ * The length of data in bytes.
+ */
+ decode: function(dataLen) {
+ let GsmPDUHelper = this.context.GsmPDUHelper;
+
+ let hlen = 0;
+ let tag = GsmPDUHelper.readHexOctet();
+ hlen++;
+
+ // The length is coded onto 1 or 2 bytes.
+ // Length | Byte 1 | Byte 2
+ // 0 - 127 | length ('00' to '7f') | N/A
+ // 128 - 255 | '81' | length ('80' to 'ff')
+ let length;
+ let temp = GsmPDUHelper.readHexOctet();
+ hlen++;
+ if (temp < 0x80) {
+ length = temp;
+ } else if (temp === 0x81) {
+ length = GsmPDUHelper.readHexOctet();
+ hlen++;
+ if (length < 0x80) {
+ throw new Error("Invalid length " + length);
+ }
+ } else {
+ throw new Error("Invalid length octet " + temp);
+ }
+
+ // Header + body length check.
+ if (dataLen - hlen !== length) {
+ throw new Error("Unexpected BerTlvHelper value length!!");
+ }
+
+ let method = this[tag];
+ if (typeof method != "function") {
+ throw new Error("Unknown Ber tag 0x" + tag.toString(16));
+ }
+
+ let value = method.call(this, length);
+
+ return {
+ tag: tag,
+ length: length,
+ value: value
+ };
+ },
+
+ /**
+ * Process the value part for FCP template TLV.
+ *
+ * @param length
+ * The length of data in bytes.
+ */
+ processFcpTemplate: function(length) {
+ let tlvs = this.decodeChunks(length);
+ return tlvs;
+ },
+
+ /**
+ * Process the value part for proactive command TLV.
+ *
+ * @param length
+ * The length of data in bytes.
+ */
+ processProactiveCommand: function(length) {
+ let ctlvs = this.context.ComprehensionTlvHelper.decodeChunks(length);
+ return ctlvs;
+ },
+
+ /**
+ * Decode raw data to a Ber-TLV.
+ */
+ decodeInnerTlv: function() {
+ let GsmPDUHelper = this.context.GsmPDUHelper;
+ let tag = GsmPDUHelper.readHexOctet();
+ let length = GsmPDUHelper.readHexOctet();
+ return {
+ tag: tag,
+ length: length,
+ value: this.retrieve(tag, length)
+ };
+ },
+
+ decodeChunks: function(length) {
+ let chunks = [];
+ let index = 0;
+ while (index < length) {
+ let tlv = this.decodeInnerTlv();
+ if (tlv.value) {
+ chunks.push(tlv);
+ }
+ index += tlv.length;
+ // tag + length fields consume 2 bytes.
+ index += 2;
+ }
+ return chunks;
+ },
+
+ retrieve: function(tag, length) {
+ let method = this[tag];
+ if (typeof method != "function") {
+ if (DEBUG) {
+ this.context.debug("Unknown Ber tag : 0x" + tag.toString(16));
+ }
+ let Buf = this.context.Buf;
+ Buf.seekIncoming(length * Buf.PDU_HEX_OCTET_SIZE);
+ return null;
+ }
+ return method.call(this, length);
+ },
+
+ /**
+ * File Size Data.
+ *
+ * | Byte | Description | Length |
+ * | 1 | Tag | 1 |
+ * | 2 | Length | 1 |
+ * | 3 to X+24 | Number of allocated data bytes in the file | X |
+ * | | , excluding structural information | |
+ */
+ retrieveFileSizeData: function(length) {
+ let GsmPDUHelper = this.context.GsmPDUHelper;
+ let fileSizeData = 0;
+ for (let i = 0; i < length; i++) {
+ fileSizeData = fileSizeData << 8;
+ fileSizeData += GsmPDUHelper.readHexOctet();
+ }
+
+ return {fileSizeData: fileSizeData};
+ },
+
+ /**
+ * File Descriptor.
+ *
+ * | Byte | Description | Length |
+ * | 1 | Tag | 1 |
+ * | 2 | Length | 1 |
+ * | 3 | File descriptor byte | 1 |
+ * | 4 | Data coding byte | 1 |
+ * | 5 ~ 6 | Record length | 2 |
+ * | 7 | Number of records | 1 |
+ */
+ retrieveFileDescriptor: function(length) {
+ let GsmPDUHelper = this.context.GsmPDUHelper;
+ let fileDescriptorByte = GsmPDUHelper.readHexOctet();
+ let dataCodingByte = GsmPDUHelper.readHexOctet();
+ // See TS 102 221 Table 11.5, we only care the least 3 bits for the
+ // structure of file.
+ let fileStructure = fileDescriptorByte & 0x07;
+
+ let fileDescriptor = {
+ fileStructure: fileStructure
+ };
+ // byte 5 ~ 7 are mandatory for linear fixed and cyclic files, otherwise
+ // they are not applicable.
+ if (fileStructure === UICC_EF_STRUCTURE[EF_STRUCTURE_LINEAR_FIXED] ||
+ fileStructure === UICC_EF_STRUCTURE[EF_STRUCTURE_CYCLIC]) {
+ fileDescriptor.recordLength = (GsmPDUHelper.readHexOctet() << 8) +
+ GsmPDUHelper.readHexOctet();
+ fileDescriptor.numOfRecords = GsmPDUHelper.readHexOctet();
+ }
+
+ return fileDescriptor;
+ },
+
+ /**
+ * File identifier.
+ *
+ * | Byte | Description | Length |
+ * | 1 | Tag | 1 |
+ * | 2 | Length | 1 |
+ * | 3 ~ 4 | File identifier | 2 |
+ */
+ retrieveFileIdentifier: function(length) {
+ let GsmPDUHelper = this.context.GsmPDUHelper;
+ return {fileId : (GsmPDUHelper.readHexOctet() << 8) +
+ GsmPDUHelper.readHexOctet()};
+ },
+
+ searchForNextTag: function(tag, iter) {
+ for (let tlv of iter) {
+ if (tlv.tag === tag) {
+ return tlv;
+ }
+ }
+ return null;
+ }
+};
+BerTlvHelperObject.prototype[BER_FCP_TEMPLATE_TAG] = function BER_FCP_TEMPLATE_TAG(length) {
+ return this.processFcpTemplate(length);
+};
+BerTlvHelperObject.prototype[BER_PROACTIVE_COMMAND_TAG] = function BER_PROACTIVE_COMMAND_TAG(length) {
+ return this.processProactiveCommand(length);
+};
+BerTlvHelperObject.prototype[BER_FCP_FILE_SIZE_DATA_TAG] = function BER_FCP_FILE_SIZE_DATA_TAG(length) {
+ return this.retrieveFileSizeData(length);
+};
+BerTlvHelperObject.prototype[BER_FCP_FILE_DESCRIPTOR_TAG] = function BER_FCP_FILE_DESCRIPTOR_TAG(length) {
+ return this.retrieveFileDescriptor(length);
+};
+BerTlvHelperObject.prototype[BER_FCP_FILE_IDENTIFIER_TAG] = function BER_FCP_FILE_IDENTIFIER_TAG(length) {
+ return this.retrieveFileIdentifier(length);
+};
+
+/**
+ * ICC Helper for getting EF path.
+ */
+function ICCFileHelperObject(aContext) {
+ this.context = aContext;
+}
+ICCFileHelperObject.prototype = {
+ context: null,
+
+ /**
+ * This function handles only EFs that are common to RUIM, SIM, USIM
+ * and other types of ICC cards.
+ */
+ getCommonEFPath: function(fileId) {
+ switch (fileId) {
+ case ICC_EF_ICCID:
+ return EF_PATH_MF_SIM;
+ case ICC_EF_ADN:
+ case ICC_EF_SDN: // Fall through.
+ return EF_PATH_MF_SIM + EF_PATH_DF_TELECOM;
+ case ICC_EF_PBR:
+ return EF_PATH_MF_SIM + EF_PATH_DF_TELECOM + EF_PATH_DF_PHONEBOOK;
+ case ICC_EF_IMG:
+ return EF_PATH_MF_SIM + EF_PATH_DF_TELECOM + EF_PATH_GRAPHICS;
+ }
+ return null;
+ },
+
+ /**
+ * This function handles EFs for SIM.
+ */
+ getSimEFPath: function(fileId) {
+ switch (fileId) {
+ case ICC_EF_FDN:
+ case ICC_EF_MSISDN:
+ case ICC_EF_SMS:
+ case ICC_EF_EXT1:
+ case ICC_EF_EXT2:
+ case ICC_EF_EXT3:
+ return EF_PATH_MF_SIM + EF_PATH_DF_TELECOM;
+ case ICC_EF_AD:
+ case ICC_EF_MBDN:
+ case ICC_EF_MWIS:
+ case ICC_EF_PLMNsel:
+ case ICC_EF_SPN:
+ case ICC_EF_SPDI:
+ case ICC_EF_SST:
+ case ICC_EF_PHASE:
+ case ICC_EF_CBMI:
+ case ICC_EF_CBMID:
+ case ICC_EF_CBMIR:
+ case ICC_EF_OPL:
+ case ICC_EF_PNN:
+ case ICC_EF_GID1:
+ case ICC_EF_CPHS_INFO:
+ case ICC_EF_CPHS_MBN:
+ return EF_PATH_MF_SIM + EF_PATH_DF_GSM;
+ default:
+ return null;
+ }
+ },
+
+ /**
+ * This function handles EFs for USIM.
+ */
+ getUSimEFPath: function(fileId) {
+ switch (fileId) {
+ case ICC_EF_AD:
+ case ICC_EF_FDN:
+ case ICC_EF_MBDN:
+ case ICC_EF_MWIS:
+ case ICC_EF_UST:
+ case ICC_EF_MSISDN:
+ case ICC_EF_SPN:
+ case ICC_EF_SPDI:
+ case ICC_EF_CBMI:
+ case ICC_EF_CBMID:
+ case ICC_EF_CBMIR:
+ case ICC_EF_OPL:
+ case ICC_EF_PNN:
+ case ICC_EF_SMS:
+ case ICC_EF_GID1:
+ // CPHS spec was provided in 1997 based on SIM requirement, there is no
+ // detailed info about how these ICC_EF_CPHS_XXX are allocated in USIM.
+ // What we can do now is to follow what has been done in AOSP to have file
+ // path equal to MF_SIM/DF_GSM.
+ case ICC_EF_CPHS_INFO:
+ case ICC_EF_CPHS_MBN:
+ return EF_PATH_MF_SIM + EF_PATH_ADF_USIM;
+ default:
+ // The file ids in USIM phone book entries are decided by the
+ // card manufacturer. So if we don't match any of the cases
+ // above and if its a USIM return the phone book path.
+ return EF_PATH_MF_SIM + EF_PATH_DF_TELECOM + EF_PATH_DF_PHONEBOOK;
+ }
+ },
+
+ /**
+ * This function handles EFs for RUIM
+ */
+ getRuimEFPath: function(fileId) {
+ switch(fileId) {
+ case ICC_EF_CSIM_IMSI_M:
+ case ICC_EF_CSIM_CDMAHOME:
+ case ICC_EF_CSIM_CST:
+ case ICC_EF_CSIM_SPN:
+ return EF_PATH_MF_SIM + EF_PATH_DF_CDMA;
+ case ICC_EF_FDN:
+ case ICC_EF_EXT1:
+ case ICC_EF_EXT2:
+ case ICC_EF_EXT3:
+ return EF_PATH_MF_SIM + EF_PATH_DF_TELECOM;
+ default:
+ return null;
+ }
+ },
+
+ /**
+ * Helper function for getting the pathId for the specific ICC record
+ * depeding on which type of ICC card we are using.
+ *
+ * @param fileId
+ * File id.
+ * @return The pathId or null in case of an error or invalid input.
+ */
+ getEFPath: function(fileId) {
+ let path = this.getCommonEFPath(fileId);
+ if (path) {
+ return path;
+ }
+
+ switch (this.context.RIL.appType) {
+ case CARD_APPTYPE_SIM:
+ return this.getSimEFPath(fileId);
+ case CARD_APPTYPE_USIM:
+ return this.getUSimEFPath(fileId);
+ case CARD_APPTYPE_RUIM:
+ return this.getRuimEFPath(fileId);
+ default:
+ return null;
+ }
+ }
+};
+
+/**
+ * Helper for ICC IO functionalities.
+ */
+function ICCIOHelperObject(aContext) {
+ this.context = aContext;
+}
+ICCIOHelperObject.prototype = {
+ context: null,
+
+ /**
+ * Load EF with type 'Linear Fixed'.
+ *
+ * @param fileId
+ * The file to operate on, one of the ICC_EF_* constants.
+ * @param recordNumber [optional]
+ * The number of the record shall be loaded.
+ * @param recordSize [optional]
+ * The size of the record.
+ * @param callback [optional]
+ * The callback function shall be called when the record(s) is read.
+ * @param onerror [optional]
+ * The callback function shall be called when failure.
+ */
+ loadLinearFixedEF: function(options) {
+ let cb;
+ let readRecord = (function(options) {
+ options.command = ICC_COMMAND_READ_RECORD;
+ options.p1 = options.recordNumber || 1; // Record number
+ options.p2 = READ_RECORD_ABSOLUTE_MODE;
+ options.p3 = options.recordSize;
+ options.callback = cb || options.callback;
+ this.context.RIL.iccIO(options);
+ }).bind(this);
+
+ options.structure = EF_STRUCTURE_LINEAR_FIXED;
+ options.pathId = this.context.ICCFileHelper.getEFPath(options.fileId);
+ if (options.recordSize) {
+ readRecord(options);
+ return;
+ }
+
+ cb = options.callback;
+ options.callback = readRecord;
+ this.getResponse(options);
+ },
+
+ /**
+ * Load next record from current record Id.
+ */
+ loadNextRecord: function(options) {
+ options.p1++;
+ this.context.RIL.iccIO(options);
+ },
+
+ /**
+ * Update EF with type 'Linear Fixed'.
+ *
+ * @param fileId
+ * The file to operate on, one of the ICC_EF_* constants.
+ * @param recordNumber
+ * The number of the record shall be updated.
+ * @param dataWriter [optional]
+ * The function for writing string parameter for the ICC_COMMAND_UPDATE_RECORD.
+ * @param pin2 [optional]
+ * PIN2 is required when updating ICC_EF_FDN.
+ * @param callback [optional]
+ * The callback function shall be called when the record is updated.
+ * @param onerror [optional]
+ * The callback function shall be called when failure.
+ */
+ updateLinearFixedEF: function(options) {
+ if (!options.fileId || !options.recordNumber) {
+ throw new Error("Unexpected fileId " + options.fileId +
+ " or recordNumber " + options.recordNumber);
+ }
+
+ options.structure = EF_STRUCTURE_LINEAR_FIXED;
+ options.pathId = this.context.ICCFileHelper.getEFPath(options.fileId);
+ let cb = options.callback;
+ options.callback = function callback(options) {
+ options.callback = cb;
+ options.command = ICC_COMMAND_UPDATE_RECORD;
+ options.p1 = options.recordNumber;
+ options.p2 = READ_RECORD_ABSOLUTE_MODE;
+ options.p3 = options.recordSize;
+ this.context.RIL.iccIO(options);
+ }.bind(this);
+ this.getResponse(options);
+ },
+
+ /**
+ * Load EF with type 'Transparent'.
+ *
+ * @param fileId
+ * The file to operate on, one of the ICC_EF_* constants.
+ * @param callback [optional]
+ * The callback function shall be called when the record(s) is read.
+ * @param onerror [optional]
+ * The callback function shall be called when failure.
+ */
+ loadTransparentEF: function(options) {
+ options.structure = EF_STRUCTURE_TRANSPARENT;
+ let cb = options.callback;
+ options.callback = function callback(options) {
+ options.callback = cb;
+ options.command = ICC_COMMAND_READ_BINARY;
+ options.p2 = 0x00;
+ options.p3 = options.fileSize;
+ this.context.RIL.iccIO(options);
+ }.bind(this);
+ this.getResponse(options);
+ },
+
+ /**
+ * Use ICC_COMMAND_GET_RESPONSE to query the EF.
+ *
+ * @param fileId
+ * The file to operate on, one of the ICC_EF_* constants.
+ */
+ getResponse: function(options) {
+ options.command = ICC_COMMAND_GET_RESPONSE;
+ options.pathId = options.pathId ||
+ this.context.ICCFileHelper.getEFPath(options.fileId);
+ if (!options.pathId) {
+ throw new Error("Unknown pathId for " + options.fileId.toString(16));
+ }
+ options.p1 = 0; // For GET_RESPONSE, p1 = 0
+ switch (this.context.RIL.appType) {
+ case CARD_APPTYPE_USIM:
+ options.p2 = GET_RESPONSE_FCP_TEMPLATE;
+ options.p3 = 0x00;
+ break;
+ // For RUIM, CSIM and ISIM, cf bug 955946: keep the old behavior
+ case CARD_APPTYPE_RUIM:
+ case CARD_APPTYPE_CSIM:
+ case CARD_APPTYPE_ISIM:
+ // For SIM, this is what we want
+ case CARD_APPTYPE_SIM:
+ default:
+ options.p2 = 0x00;
+ options.p3 = GET_RESPONSE_EF_SIZE_BYTES;
+ break;
+ }
+ this.context.RIL.iccIO(options);
+ },
+
+ /**
+ * Process ICC I/O response.
+ */
+ processICCIO: function(options) {
+ let func = this[options.command];
+ func.call(this, options);
+ },
+
+ /**
+ * Process a ICC_COMMAND_GET_RESPONSE type command for REQUEST_SIM_IO.
+ */
+ processICCIOGetResponse: function(options) {
+ let Buf = this.context.Buf;
+ let strLen = Buf.readInt32();
+
+ let peek = this.context.GsmPDUHelper.readHexOctet();
+ Buf.seekIncoming(-1 * Buf.PDU_HEX_OCTET_SIZE);
+ if (peek === BER_FCP_TEMPLATE_TAG) {
+ this.processUSimGetResponse(options, strLen / 2);
+ } else {
+ this.processSimGetResponse(options);
+ }
+ Buf.readStringDelimiter(strLen);
+
+ if (options.callback) {
+ options.callback(options);
+ }
+ },
+
+ /**
+ * Helper function for processing USIM get response.
+ */
+ processUSimGetResponse: function(options, octetLen) {
+ let BerTlvHelper = this.context.BerTlvHelper;
+
+ let berTlv = BerTlvHelper.decode(octetLen);
+ // See TS 102 221 Table 11.4 for the content order of getResponse.
+ let iter = berTlv.value.values();
+ let tlv = BerTlvHelper.searchForNextTag(BER_FCP_FILE_DESCRIPTOR_TAG,
+ iter);
+ if (!tlv ||
+ (tlv.value.fileStructure !== UICC_EF_STRUCTURE[options.structure])) {
+ throw new Error("Expected EF structure " +
+ UICC_EF_STRUCTURE[options.structure] +
+ " but read " + tlv.value.fileStructure);
+ }
+
+ if (tlv.value.fileStructure === UICC_EF_STRUCTURE[EF_STRUCTURE_LINEAR_FIXED] ||
+ tlv.value.fileStructure === UICC_EF_STRUCTURE[EF_STRUCTURE_CYCLIC]) {
+ options.recordSize = tlv.value.recordLength;
+ options.totalRecords = tlv.value.numOfRecords;
+ }
+
+ tlv = BerTlvHelper.searchForNextTag(BER_FCP_FILE_IDENTIFIER_TAG, iter);
+ if (!tlv || (tlv.value.fileId !== options.fileId)) {
+ throw new Error("Expected file ID " + options.fileId.toString(16) +
+ " but read " + fileId.toString(16));
+ }
+
+ tlv = BerTlvHelper.searchForNextTag(BER_FCP_FILE_SIZE_DATA_TAG, iter);
+ if (!tlv) {
+ throw new Error("Unexpected file size data");
+ }
+ options.fileSize = tlv.value.fileSizeData;
+ },
+
+ /**
+ * Helper function for processing SIM get response.
+ */
+ processSimGetResponse: function(options) {
+ let Buf = this.context.Buf;
+ let GsmPDUHelper = this.context.GsmPDUHelper;
+
+ // The format is from TS 51.011, clause 9.2.1
+
+ // Skip RFU, data[0] data[1].
+ Buf.seekIncoming(2 * Buf.PDU_HEX_OCTET_SIZE);
+
+ // File size, data[2], data[3]
+ options.fileSize = (GsmPDUHelper.readHexOctet() << 8) |
+ GsmPDUHelper.readHexOctet();
+
+ // 2 bytes File id. data[4], data[5]
+ let fileId = (GsmPDUHelper.readHexOctet() << 8) |
+ GsmPDUHelper.readHexOctet();
+ if (fileId != options.fileId) {
+ throw new Error("Expected file ID " + options.fileId.toString(16) +
+ " but read " + fileId.toString(16));
+ }
+
+ // Type of file, data[6]
+ let fileType = GsmPDUHelper.readHexOctet();
+ if (fileType != TYPE_EF) {
+ throw new Error("Unexpected file type " + fileType);
+ }
+
+ // Skip 1 byte RFU, data[7],
+ // 3 bytes Access conditions, data[8] data[9] data[10],
+ // 1 byte File status, data[11],
+ // 1 byte Length of the following data, data[12].
+ Buf.seekIncoming(((RESPONSE_DATA_STRUCTURE - RESPONSE_DATA_FILE_TYPE - 1) *
+ Buf.PDU_HEX_OCTET_SIZE));
+
+ // Read Structure of EF, data[13]
+ let efStructure = GsmPDUHelper.readHexOctet();
+ if (efStructure != options.structure) {
+ throw new Error("Expected EF structure " + options.structure +
+ " but read " + efStructure);
+ }
+
+ // Length of a record, data[14].
+ // Only available for LINEAR_FIXED and CYCLIC.
+ if (efStructure == EF_STRUCTURE_LINEAR_FIXED ||
+ efStructure == EF_STRUCTURE_CYCLIC) {
+ options.recordSize = GsmPDUHelper.readHexOctet();
+ options.totalRecords = options.fileSize / options.recordSize;
+ } else {
+ Buf.seekIncoming(1 * Buf.PDU_HEX_OCTET_SIZE);
+ }
+ },
+
+ /**
+ * Process a ICC_COMMAND_READ_RECORD type command for REQUEST_SIM_IO.
+ */
+ processICCIOReadRecord: function(options) {
+ if (options.callback) {
+ options.callback(options);
+ }
+ },
+
+ /**
+ * Process a ICC_COMMAND_READ_BINARY type command for REQUEST_SIM_IO.
+ */
+ processICCIOReadBinary: function(options) {
+ if (options.callback) {
+ options.callback(options);
+ }
+ },
+
+ /**
+ * Process a ICC_COMMAND_UPDATE_RECORD type command for REQUEST_SIM_IO.
+ */
+ processICCIOUpdateRecord: function(options) {
+ if (options.callback) {
+ options.callback(options);
+ }
+ },
+};
+ICCIOHelperObject.prototype[ICC_COMMAND_SEEK] = null;
+ICCIOHelperObject.prototype[ICC_COMMAND_READ_BINARY] = function ICC_COMMAND_READ_BINARY(options) {
+ this.processICCIOReadBinary(options);
+};
+ICCIOHelperObject.prototype[ICC_COMMAND_READ_RECORD] = function ICC_COMMAND_READ_RECORD(options) {
+ this.processICCIOReadRecord(options);
+};
+ICCIOHelperObject.prototype[ICC_COMMAND_GET_RESPONSE] = function ICC_COMMAND_GET_RESPONSE(options) {
+ this.processICCIOGetResponse(options);
+};
+ICCIOHelperObject.prototype[ICC_COMMAND_UPDATE_BINARY] = null;
+ICCIOHelperObject.prototype[ICC_COMMAND_UPDATE_RECORD] = function ICC_COMMAND_UPDATE_RECORD(options) {
+ this.processICCIOUpdateRecord(options);
+};
+
+/**
+ * Helper for ICC records.
+ */
+function ICCRecordHelperObject(aContext) {
+ this.context = aContext;
+ // Cache the possible free record id for all files, use fileId as key.
+ this._freeRecordIds = {};
+}
+ICCRecordHelperObject.prototype = {
+ context: null,
+
+ /**
+ * Fetch ICC records.
+ */
+ fetchICCRecords: function() {
+ switch (this.context.RIL.appType) {
+ case CARD_APPTYPE_SIM:
+ case CARD_APPTYPE_USIM:
+ this.context.SimRecordHelper.fetchSimRecords();
+ break;
+ case CARD_APPTYPE_RUIM:
+ this.context.RuimRecordHelper.fetchRuimRecords();
+ break;
+ }
+ },
+
+ /**
+ * Read the ICCID.
+ */
+ readICCID: function() {
+ function callback() {
+ let Buf = this.context.Buf;
+ let RIL = this.context.RIL;
+ let GsmPDUHelper = this.context.GsmPDUHelper;
+
+ let strLen = Buf.readInt32();
+ let octetLen = strLen / 2;
+ RIL.iccInfo.iccid =
+ GsmPDUHelper.readSwappedNibbleBcdString(octetLen, true);
+ // Consumes the remaining buffer if any.
+ let unReadBuffer = this.context.Buf.getReadAvailable() -
+ this.context.Buf.PDU_HEX_OCTET_SIZE;
+ if (unReadBuffer > 0) {
+ this.context.Buf.seekIncoming(unReadBuffer);
+ }
+ Buf.readStringDelimiter(strLen);
+
+ if (DEBUG) this.context.debug("ICCID: " + RIL.iccInfo.iccid);
+ if (RIL.iccInfo.iccid) {
+ this.context.ICCUtilsHelper.handleICCInfoChange();
+ RIL.reportStkServiceIsRunning();
+ }
+ }
+
+ this.context.ICCIOHelper.loadTransparentEF({
+ fileId: ICC_EF_ICCID,
+ callback: callback.bind(this)
+ });
+ },
+
+ /**
+ * Read ICC ADN like EF, i.e. EF_ADN, EF_FDN.
+ *
+ * @param fileId EF id of the ADN, FDN or SDN.
+ * @param extFileId EF id of the EXT.
+ * @param onsuccess Callback to be called when success.
+ * @param onerror Callback to be called when error.
+ */
+ readADNLike: function(fileId, extFileId, onsuccess, onerror) {
+ let ICCIOHelper = this.context.ICCIOHelper;
+
+ function callback(options) {
+ let loadNextContactRecord = () => {
+ if (options.p1 < options.totalRecords) {
+ ICCIOHelper.loadNextRecord(options);
+ return;
+ }
+ if (DEBUG) {
+ for (let i = 0; i < contacts.length; i++) {
+ this.context.debug("contact [" + i + "] " +
+ JSON.stringify(contacts[i]));
+ }
+ }
+ if (onsuccess) {
+ onsuccess(contacts);
+ }
+ };
+
+ let contact =
+ this.context.ICCPDUHelper.readAlphaIdDiallingNumber(options.recordSize);
+ if (contact) {
+ let record = {
+ recordId: options.p1,
+ alphaId: contact.alphaId,
+ number: contact.number
+ };
+ contacts.push(record);
+
+ if (extFileId && contact.extRecordNumber != 0xff) {
+ this.readExtension(extFileId, contact.extRecordNumber, (number) => {
+ if (number) {
+ record.number += number;
+ }
+ loadNextContactRecord();
+ }, () => loadNextContactRecord());
+ return;
+ }
+ }
+ loadNextContactRecord();
+ }
+
+ let contacts = [];
+ ICCIOHelper.loadLinearFixedEF({fileId: fileId,
+ callback: callback.bind(this),
+ onerror: onerror});
+ },
+
+ /**
+ * Update ICC ADN like EFs, like EF_ADN, EF_FDN.
+ *
+ * @param fileId EF id of the ADN or FDN.
+ * @param extRecordNumber The record identifier of the EXT.
+ * @param contact The contact will be updated. (Shall have recordId property)
+ * @param pin2 PIN2 is required when updating ICC_EF_FDN.
+ * @param onsuccess Callback to be called when success.
+ * @param onerror Callback to be called when error.
+ */
+ updateADNLike: function(fileId, extRecordNumber, contact, pin2, onsuccess, onerror) {
+ let updatedContact;
+ function dataWriter(recordSize) {
+ updatedContact = this.context.ICCPDUHelper.writeAlphaIdDiallingNumber(recordSize,
+ contact.alphaId,
+ contact.number,
+ extRecordNumber);
+ }
+
+ function callback(options) {
+ if (onsuccess) {
+ onsuccess(updatedContact);
+ }
+ }
+
+ if (!contact || !contact.recordId) {
+ if (onerror) onerror(GECKO_ERROR_INVALID_PARAMETER);
+ return;
+ }
+
+ this.context.ICCIOHelper.updateLinearFixedEF({
+ fileId: fileId,
+ recordNumber: contact.recordId,
+ dataWriter: dataWriter.bind(this),
+ pin2: pin2,
+ callback: callback.bind(this),
+ onerror: onerror
+ });
+ },
+
+ /**
+ * Read USIM/RUIM Phonebook.
+ *
+ * @param onsuccess Callback to be called when success.
+ * @param onerror Callback to be called when error.
+ */
+ readPBR: function(onsuccess, onerror) {
+ let Buf = this.context.Buf;
+ let GsmPDUHelper = this.context.GsmPDUHelper;
+ let ICCIOHelper = this.context.ICCIOHelper;
+ let ICCUtilsHelper = this.context.ICCUtilsHelper;
+ let RIL = this.context.RIL;
+
+ function callback(options) {
+ let strLen = Buf.readInt32();
+ let octetLen = strLen / 2, readLen = 0;
+
+ let pbrTlvs = [];
+ while (readLen < octetLen) {
+ let tag = GsmPDUHelper.readHexOctet();
+ if (tag == 0xff) {
+ readLen++;
+ Buf.seekIncoming((octetLen - readLen) * Buf.PDU_HEX_OCTET_SIZE);
+ break;
+ }
+
+ let tlvLen = GsmPDUHelper.readHexOctet();
+ let tlvs = ICCUtilsHelper.decodeSimTlvs(tlvLen);
+ pbrTlvs.push({tag: tag,
+ length: tlvLen,
+ value: tlvs});
+
+ readLen += tlvLen + 2; // +2 for tag and tlvLen
+ }
+ Buf.readStringDelimiter(strLen);
+
+ if (pbrTlvs.length > 0) {
+ let pbr = ICCUtilsHelper.parsePbrTlvs(pbrTlvs);
+ // EF_ADN is mandatory if and only if DF_PHONEBOOK is present.
+ if (!pbr.adn) {
+ if (onerror) onerror("Cannot access ADN.");
+ return;
+ }
+ pbrs.push(pbr);
+ }
+
+ if (options.p1 < options.totalRecords) {
+ ICCIOHelper.loadNextRecord(options);
+ } else {
+ if (onsuccess) {
+ RIL.iccInfoPrivate.pbrs = pbrs;
+ onsuccess(pbrs);
+ }
+ }
+ }
+
+ if (RIL.iccInfoPrivate.pbrs) {
+ onsuccess(RIL.iccInfoPrivate.pbrs);
+ return;
+ }
+
+ let pbrs = [];
+ ICCIOHelper.loadLinearFixedEF({fileId : ICC_EF_PBR,
+ callback: callback.bind(this),
+ onerror: onerror});
+ },
+
+ /**
+ * Cache EF_IAP record size.
+ */
+ _iapRecordSize: null,
+
+ /**
+ * Read ICC EF_IAP. (Index Administration Phonebook)
+ *
+ * @see TS 131.102, clause 4.4.2.2
+ *
+ * @param fileId EF id of the IAP.
+ * @param recordNumber The number of the record shall be loaded.
+ * @param onsuccess Callback to be called when success.
+ * @param onerror Callback to be called when error.
+ */
+ readIAP: function(fileId, recordNumber, onsuccess, onerror) {
+ function callback(options) {
+ let Buf = this.context.Buf;
+ let strLen = Buf.readInt32();
+ let octetLen = strLen / 2;
+ this._iapRecordSize = options.recordSize;
+
+ let iap = this.context.GsmPDUHelper.readHexOctetArray(octetLen);
+ Buf.readStringDelimiter(strLen);
+
+ if (onsuccess) {
+ onsuccess(iap);
+ }
+ }
+
+ this.context.ICCIOHelper.loadLinearFixedEF({
+ fileId: fileId,
+ recordNumber: recordNumber,
+ recordSize: this._iapRecordSize,
+ callback: callback.bind(this),
+ onerror: onerror
+ });
+ },
+
+ /**
+ * Update USIM/RUIM Phonebook EF_IAP.
+ *
+ * @see TS 131.102, clause 4.4.2.13
+ *
+ * @param fileId EF id of the IAP.
+ * @param recordNumber The identifier of the record shall be updated.
+ * @param iap The IAP value to be written.
+ * @param onsuccess Callback to be called when success.
+ * @param onerror Callback to be called when error.
+ */
+ updateIAP: function(fileId, recordNumber, iap, onsuccess, onerror) {
+ let dataWriter = function dataWriter(recordSize) {
+ let Buf = this.context.Buf;
+ let GsmPDUHelper = this.context.GsmPDUHelper;
+
+ // Write String length
+ let strLen = recordSize * 2;
+ Buf.writeInt32(strLen);
+
+ for (let i = 0; i < iap.length; i++) {
+ GsmPDUHelper.writeHexOctet(iap[i]);
+ }
+
+ Buf.writeStringDelimiter(strLen);
+ }.bind(this);
+
+ this.context.ICCIOHelper.updateLinearFixedEF({
+ fileId: fileId,
+ recordNumber: recordNumber,
+ dataWriter: dataWriter,
+ callback: onsuccess,
+ onerror: onerror
+ });
+ },
+
+ /**
+ * Cache EF_Email record size.
+ */
+ _emailRecordSize: null,
+
+ /**
+ * Read USIM/RUIM Phonebook EF_EMAIL.
+ *
+ * @see TS 131.102, clause 4.4.2.13
+ *
+ * @param fileId EF id of the EMAIL.
+ * @param fileType The type of the EMAIL, one of the ICC_USIM_TYPE* constants.
+ * @param recordNumber The number of the record shall be loaded.
+ * @param onsuccess Callback to be called when success.
+ * @param onerror Callback to be called when error.
+ */
+ readEmail: function(fileId, fileType, recordNumber, onsuccess, onerror) {
+ function callback(options) {
+ let Buf = this.context.Buf;
+ let ICCPDUHelper = this.context.ICCPDUHelper;
+
+ let strLen = Buf.readInt32();
+ let octetLen = strLen / 2;
+ let email = null;
+ this._emailRecordSize = options.recordSize;
+
+ // Read contact's email
+ //
+ // | Byte | Description | Length | M/O
+ // | 1 ~ X | E-mail Address | X | M
+ // | X+1 | ADN file SFI | 1 | C
+ // | X+2 | ADN file Record Identifier | 1 | C
+ // Note: The fields marked as C above are mandatort if the file
+ // is not type 1 (as specified in EF_PBR)
+ if (fileType == ICC_USIM_TYPE1_TAG) {
+ email = ICCPDUHelper.read8BitUnpackedToString(octetLen);
+ } else {
+ email = ICCPDUHelper.read8BitUnpackedToString(octetLen - 2);
+
+ // Consumes the remaining buffer
+ Buf.seekIncoming(2 * Buf.PDU_HEX_OCTET_SIZE); // For ADN SFI and Record Identifier
+ }
+
+ Buf.readStringDelimiter(strLen);
+
+ if (onsuccess) {
+ onsuccess(email);
+ }
+ }
+
+ this.context.ICCIOHelper.loadLinearFixedEF({
+ fileId: fileId,
+ recordNumber: recordNumber,
+ recordSize: this._emailRecordSize,
+ callback: callback.bind(this),
+ onerror: onerror
+ });
+ },
+
+ /**
+ * Update USIM/RUIM Phonebook EF_EMAIL.
+ *
+ * @see TS 131.102, clause 4.4.2.13
+ *
+ * @param pbr Phonebook Reference File.
+ * @param recordNumber The identifier of the record shall be updated.
+ * @param email The value to be written.
+ * @param adnRecordId The record Id of ADN, only needed if the fileType of Email is TYPE2.
+ * @param onsuccess Callback to be called when success.
+ * @param onerror Callback to be called when error.
+ */
+ updateEmail: function(pbr, recordNumber, email, adnRecordId, onsuccess, onerror) {
+ let fileId = pbr[USIM_PBR_EMAIL].fileId;
+ let fileType = pbr[USIM_PBR_EMAIL].fileType;
+ let writtenEmail;
+ let dataWriter = function dataWriter(recordSize) {
+ let Buf = this.context.Buf;
+ let GsmPDUHelper = this.context.GsmPDUHelper;
+ let ICCPDUHelper = this.context.ICCPDUHelper;
+
+ // Write String length
+ let strLen = recordSize * 2;
+ Buf.writeInt32(strLen);
+
+ if (fileType == ICC_USIM_TYPE1_TAG) {
+ writtenEmail = ICCPDUHelper.writeStringTo8BitUnpacked(recordSize, email);
+ } else {
+ writtenEmail = ICCPDUHelper.writeStringTo8BitUnpacked(recordSize - 2, email);
+ GsmPDUHelper.writeHexOctet(pbr.adn.sfi || 0xff);
+ GsmPDUHelper.writeHexOctet(adnRecordId);
+ }
+
+ Buf.writeStringDelimiter(strLen);
+ }.bind(this);
+
+ let callback = (options) => {
+ if (onsuccess) {
+ onsuccess(writtenEmail);
+ }
+ }
+
+ this.context.ICCIOHelper.updateLinearFixedEF({
+ fileId: fileId,
+ recordNumber: recordNumber,
+ dataWriter: dataWriter,
+ callback: callback,
+ onerror: onerror
+ });
+ },
+
+ /**
+ * Cache EF_ANR record size.
+ */
+ _anrRecordSize: null,
+
+ /**
+ * Read USIM/RUIM Phonebook EF_ANR.
+ *
+ * @see TS 131.102, clause 4.4.2.9
+ *
+ * @param fileId EF id of the ANR.
+ * @param fileType One of the ICC_USIM_TYPE* constants.
+ * @param recordNumber The number of the record shall be loaded.
+ * @param onsuccess Callback to be called when success.
+ * @param onerror Callback to be called when error.
+ */
+ readANR: function(fileId, fileType, recordNumber, onsuccess, onerror) {
+ function callback(options) {
+ let Buf = this.context.Buf;
+ let strLen = Buf.readInt32();
+ let number = null;
+ this._anrRecordSize = options.recordSize;
+
+ // Skip EF_AAS Record ID.
+ Buf.seekIncoming(1 * Buf.PDU_HEX_OCTET_SIZE);
+
+ number = this.context.ICCPDUHelper.readNumberWithLength();
+
+ // Skip 2 unused octets, CCP and EXT1.
+ Buf.seekIncoming(2 * Buf.PDU_HEX_OCTET_SIZE);
+
+ // For Type 2 there are two extra octets.
+ if (fileType == ICC_USIM_TYPE2_TAG) {
+ // Skip 2 unused octets, ADN SFI and Record Identifier.
+ Buf.seekIncoming(2 * Buf.PDU_HEX_OCTET_SIZE);
+ }
+
+ Buf.readStringDelimiter(strLen);
+
+ if (onsuccess) {
+ onsuccess(number);
+ }
+ }
+
+ this.context.ICCIOHelper.loadLinearFixedEF({
+ fileId: fileId,
+ recordNumber: recordNumber,
+ recordSize: this._anrRecordSize,
+ callback: callback.bind(this),
+ onerror: onerror
+ });
+ },
+
+ /**
+ * Update USIM/RUIM Phonebook EF_ANR.
+ *
+ * @see TS 131.102, clause 4.4.2.9
+ *
+ * @param pbr Phonebook Reference File.
+ * @param recordNumber The identifier of the record shall be updated.
+ * @param number The value to be written.
+ * @param adnRecordId The record Id of ADN, only needed if the fileType of Email is TYPE2.
+ * @param onsuccess Callback to be called when success.
+ * @param onerror Callback to be called when error.
+ */
+ updateANR: function(pbr, recordNumber, number, adnRecordId, onsuccess, onerror) {
+ let fileId = pbr[USIM_PBR_ANR0].fileId;
+ let fileType = pbr[USIM_PBR_ANR0].fileType;
+ let writtenNumber;
+ let dataWriter = function dataWriter(recordSize) {
+ let Buf = this.context.Buf;
+ let GsmPDUHelper = this.context.GsmPDUHelper;
+
+ // Write String length
+ let strLen = recordSize * 2;
+ Buf.writeInt32(strLen);
+
+ // EF_AAS record Id. Unused for now.
+ GsmPDUHelper.writeHexOctet(0xff);
+
+ writtenNumber = this.context.ICCPDUHelper.writeNumberWithLength(number);
+
+ // Write unused octets 0xff, CCP and EXT1.
+ GsmPDUHelper.writeHexOctet(0xff);
+ GsmPDUHelper.writeHexOctet(0xff);
+
+ // For Type 2 there are two extra octets.
+ if (fileType == ICC_USIM_TYPE2_TAG) {
+ GsmPDUHelper.writeHexOctet(pbr.adn.sfi || 0xff);
+ GsmPDUHelper.writeHexOctet(adnRecordId);
+ }
+
+ Buf.writeStringDelimiter(strLen);
+ }.bind(this);
+
+ let callback = (options) => {
+ if (onsuccess) {
+ onsuccess(writtenNumber);
+ }
+ }
+
+ this.context.ICCIOHelper.updateLinearFixedEF({
+ fileId: fileId,
+ recordNumber: recordNumber,
+ dataWriter: dataWriter,
+ callback: callback,
+ onerror: onerror
+ });
+ },
+
+ /**
+ * Cache the possible free record id for all files.
+ */
+ _freeRecordIds: null,
+
+ /**
+ * Find free record id.
+ *
+ * @param fileId EF id.
+ * @param onsuccess Callback to be called when success.
+ * @param onerror Callback to be called when error.
+ */
+ findFreeRecordId: function(fileId, onsuccess, onerror) {
+ let ICCIOHelper = this.context.ICCIOHelper;
+
+ function callback(options) {
+ let Buf = this.context.Buf;
+ let GsmPDUHelper = this.context.GsmPDUHelper;
+
+ let strLen = Buf.readInt32();
+ let octetLen = strLen / 2;
+ let readLen = 0;
+
+ while (readLen < octetLen) {
+ let octet = GsmPDUHelper.readHexOctet();
+ readLen++;
+ if (octet != 0xff) {
+ break;
+ }
+ }
+
+ let nextRecord = (options.p1 % options.totalRecords) + 1;
+
+ if (readLen == octetLen) {
+ // Find free record, assume next record is probably free.
+ this._freeRecordIds[fileId] = nextRecord;
+ if (onsuccess) {
+ onsuccess(options.p1);
+ }
+ return;
+ } else {
+ Buf.seekIncoming((octetLen - readLen) * Buf.PDU_HEX_OCTET_SIZE);
+ }
+
+ Buf.readStringDelimiter(strLen);
+
+ if (nextRecord !== recordNumber) {
+ options.p1 = nextRecord;
+ this.context.RIL.iccIO(options);
+ } else {
+ // No free record found.
+ delete this._freeRecordIds[fileId];
+ if (DEBUG) {
+ this.context.debug(CONTACT_ERR_NO_FREE_RECORD_FOUND);
+ }
+ onerror(CONTACT_ERR_NO_FREE_RECORD_FOUND);
+ }
+ }
+
+ // Start searching free records from the possible one.
+ let recordNumber = this._freeRecordIds[fileId] || 1;
+ ICCIOHelper.loadLinearFixedEF({fileId: fileId,
+ recordNumber: recordNumber,
+ callback: callback.bind(this),
+ onerror: onerror});
+ },
+
+ /**
+ * Read Extension Number from TS 151.011 clause 10.5.10, TS 31.102, clause 4.4.2.4
+ *
+ * @param fileId EF Extension id
+ * @param recordNumber The number of the record shall be loaded.
+ * @param onsuccess Callback to be called when success.
+ * @param onerror Callback to be called when error.
+ */
+ readExtension: function(fileId, recordNumber, onsuccess, onerror) {
+ let callback = (options) => {
+ let Buf = this.context.Buf;
+ let length = Buf.readInt32();
+ let recordType = this.context.GsmPDUHelper.readHexOctet();
+ let number = "";
+
+ // TS 31.102, clause 4.4.2.4 EFEXT1
+ // Case 1, Extension1 record is additional data
+ if (recordType & 0x02) {
+ let numLen = this.context.GsmPDUHelper.readHexOctet();
+ if (numLen != 0xff) {
+ if (numLen > EXT_MAX_BCD_NUMBER_BYTES) {
+ if (DEBUG) {
+ this.context.debug(
+ "Error: invalid length of BCD number/SSC contents - " + numLen);
+ }
+ // +1 to skip Identifier
+ Buf.seekIncoming((EXT_MAX_BCD_NUMBER_BYTES + 1) * Buf.PDU_HEX_OCTET_SIZE);
+ Buf.readStringDelimiter(length);
+ onerror();
+ return;
+ }
+
+ number = this.context.GsmPDUHelper.readSwappedNibbleExtendedBcdString(numLen);
+ if (DEBUG) this.context.debug("Contact Extension Number: "+ number);
+ Buf.seekIncoming((EXT_MAX_BCD_NUMBER_BYTES - numLen) * Buf.PDU_HEX_OCTET_SIZE);
+ } else {
+ Buf.seekIncoming(EXT_MAX_BCD_NUMBER_BYTES * Buf.PDU_HEX_OCTET_SIZE);
+ }
+ } else {
+ // Don't support Case 2, Extension1 record is Called Party Subaddress.
+ // +1 skip numLen
+ Buf.seekIncoming((EXT_MAX_BCD_NUMBER_BYTES + 1) * Buf.PDU_HEX_OCTET_SIZE);
+ }
+
+ // Skip Identifier
+ Buf.seekIncoming(Buf.PDU_HEX_OCTET_SIZE);
+ Buf.readStringDelimiter(length);
+ onsuccess(number);
+ }
+
+ this.context.ICCIOHelper.loadLinearFixedEF({
+ fileId: fileId,
+ recordNumber: recordNumber,
+ callback: callback,
+ onerror: onerror
+ });
+ },
+
+ /**
+ * Update Extension.
+ *
+ * @param fileId EF id of the EXT.
+ * @param recordNumber The number of the record shall be updated.
+ * @param number Dialling Number to be written.
+ * @param onsuccess Callback to be called when success.
+ * @param onerror Callback to be called when error.
+ */
+ updateExtension: function(fileId, recordNumber, number, onsuccess, onerror) {
+ let dataWriter = (recordSize) => {
+ let GsmPDUHelper = this.context.GsmPDUHelper;
+ // Write String length
+ let strLen = recordSize * 2;
+ let Buf = this.context.Buf;
+ Buf.writeInt32(strLen);
+
+ // We don't support extension chain.
+ if (number.length > EXT_MAX_NUMBER_DIGITS) {
+ number = number.substring(0, EXT_MAX_NUMBER_DIGITS);
+ }
+
+ let numLen = Math.ceil(number.length / 2);
+ // Write Extension record
+ GsmPDUHelper.writeHexOctet(0x02);
+ GsmPDUHelper.writeHexOctet(numLen);
+ GsmPDUHelper.writeSwappedNibbleBCD(number);
+ // Write trailing 0xff of Extension data.
+ for (let i = 0; i < EXT_MAX_BCD_NUMBER_BYTES - numLen; i++) {
+ GsmPDUHelper.writeHexOctet(0xff);
+ }
+ // Write trailing 0xff for Identifier.
+ GsmPDUHelper.writeHexOctet(0xff);
+ Buf.writeStringDelimiter(strLen);
+ };
+
+ this.context.ICCIOHelper.updateLinearFixedEF({
+ fileId: fileId,
+ recordNumber: recordNumber,
+ dataWriter: dataWriter,
+ callback: onsuccess,
+ onerror: onerror
+ });
+ },
+
+ /**
+ * Clean an EF record.
+ *
+ * @param fileId EF id.
+ * @param recordNumber The number of the record shall be updated.
+ * @param onsuccess Callback to be called when success.
+ * @param onerror Callback to be called when error.
+ */
+ cleanEFRecord: function(fileId, recordNumber, onsuccess, onerror) {
+ let dataWriter = (recordSize) => {
+ let GsmPDUHelper = this.context.GsmPDUHelper;
+ let Buf = this.context.Buf;
+ // Write String length
+ let strLen = recordSize * 2;
+
+ Buf.writeInt32(strLen);
+ // Write record to 0xff
+ for (let i = 0; i < recordSize; i++) {
+ GsmPDUHelper.writeHexOctet(0xff);
+ }
+ Buf.writeStringDelimiter(strLen);
+ }
+
+ this.context.ICCIOHelper.updateLinearFixedEF({
+ fileId: fileId,
+ recordNumber: recordNumber,
+ dataWriter: dataWriter,
+ callback: onsuccess,
+ onerror: onerror
+ });
+ },
+
+ /**
+ * Get ADNLike extension record number.
+ *
+ * @param fileId EF id of the ADN or FDN.
+ * @param recordNumber EF record id of the ADN or FDN.
+ * @param onsuccess Callback to be called when success.
+ * @param onerror Callback to be called when error.
+ */
+ getADNLikeExtensionRecordNumber: function(fileId, recordNumber, onsuccess, onerror) {
+ let callback = (options) => {
+ let Buf = this.context.Buf;
+ let length = Buf.readInt32();
+
+ // Skip alphaLen, numLen, BCD Number, CCP octets.
+ Buf.seekIncoming((options.recordSize -1) * Buf.PDU_HEX_OCTET_SIZE);
+
+ let extRecordNumber = this.context.GsmPDUHelper.readHexOctet();
+ Buf.readStringDelimiter(length);
+
+ onsuccess(extRecordNumber);
+ }
+
+ this.context.ICCIOHelper.loadLinearFixedEF({
+ fileId: fileId,
+ recordNumber: recordNumber,
+ callback: callback,
+ onerror: onerror
+ });
+ },
+};
+
+/**
+ * Helper for (U)SIM Records.
+ */
+function SimRecordHelperObject(aContext) {
+ this.context = aContext;
+}
+SimRecordHelperObject.prototype = {
+ context: null,
+
+ /**
+ * Fetch (U)SIM records.
+ */
+ fetchSimRecords: function() {
+ this.context.RIL.getIMSI();
+ this.readAD();
+ // CPHS was widely introduced in Europe during GSM(2G) era to provide easier
+ // access to carrier's core service like voicemail, call forwarding, manual
+ // PLMN selection, and etc.
+ // Addition EF like EF_CPHS_MBN, EF_CPHS_CPHS_CFF, EF_CPHS_VWI, etc are
+ // introduced to support these feature.
+ // In USIM, the replancement of these EFs are provided. (EF_MBDN, EF_MWIS, ...)
+ // However, some carriers in Europe still rely on these EFs.
+ this.readCphsInfo(() => this.readSST(),
+ (aErrorMsg) => {
+ this.context.debug("Failed to read CPHS_INFO: " + aErrorMsg);
+ this.readSST();
+ });
+ },
+
+ /**
+ * Read EF_phase.
+ * This EF is only available in SIM.
+ */
+ readSimPhase: function() {
+ function callback() {
+ let Buf = this.context.Buf;
+ let strLen = Buf.readInt32();
+
+ let GsmPDUHelper = this.context.GsmPDUHelper;
+ let phase = GsmPDUHelper.readHexOctet();
+ // If EF_phase is coded '03' or greater, an ME supporting STK shall
+ // perform the PROFILE DOWNLOAD procedure.
+ if (RILQUIRKS_SEND_STK_PROFILE_DOWNLOAD &&
+ phase >= ICC_PHASE_2_PROFILE_DOWNLOAD_REQUIRED) {
+ this.context.RIL.sendStkTerminalProfile(STK_SUPPORTED_TERMINAL_PROFILE);
+ }
+
+ Buf.readStringDelimiter(strLen);
+ }
+
+ this.context.ICCIOHelper.loadTransparentEF({
+ fileId: ICC_EF_PHASE,
+ callback: callback.bind(this)
+ });
+ },
+
+ /**
+ * Read the MSISDN from the (U)SIM.
+ */
+ readMSISDN: function() {
+ function callback(options) {
+ let RIL = this.context.RIL;
+
+ let contact =
+ this.context.ICCPDUHelper.readAlphaIdDiallingNumber(options.recordSize);
+ if (!contact ||
+ (RIL.iccInfo.msisdn !== undefined &&
+ RIL.iccInfo.msisdn === contact.number)) {
+ return;
+ }
+ RIL.iccInfo.msisdn = contact.number;
+ if (DEBUG) this.context.debug("MSISDN: " + RIL.iccInfo.msisdn);
+ this.context.ICCUtilsHelper.handleICCInfoChange();
+ }
+
+ this.context.ICCIOHelper.loadLinearFixedEF({
+ fileId: ICC_EF_MSISDN,
+ callback: callback.bind(this)
+ });
+ },
+
+ /**
+ * Read the AD (Administrative Data) from the (U)SIM.
+ */
+ readAD: function() {
+ function callback() {
+ let Buf = this.context.Buf;
+ let strLen = Buf.readInt32();
+ // Each octet is encoded into two chars.
+ let octetLen = strLen / 2;
+ let ad = this.context.GsmPDUHelper.readHexOctetArray(octetLen);
+ Buf.readStringDelimiter(strLen);
+
+ if (DEBUG) {
+ let str = "";
+ for (let i = 0; i < ad.length; i++) {
+ str += ad[i] + ", ";
+ }
+ this.context.debug("AD: " + str);
+ }
+
+ let ICCUtilsHelper = this.context.ICCUtilsHelper;
+ let RIL = this.context.RIL;
+ // TS 31.102, clause 4.2.18 EFAD
+ let mncLength = 0;
+ if (ad && ad[3]) {
+ mncLength = ad[3] & 0x0f;
+ if (mncLength != 0x02 && mncLength != 0x03) {
+ mncLength = 0;
+ }
+ }
+ // The 4th byte of the response is the length of MNC.
+ let mccMnc = ICCUtilsHelper.parseMccMncFromImsi(RIL.iccInfoPrivate.imsi,
+ mncLength);
+ if (mccMnc) {
+ RIL.iccInfo.mcc = mccMnc.mcc;
+ RIL.iccInfo.mnc = mccMnc.mnc;
+ ICCUtilsHelper.handleICCInfoChange();
+ }
+ }
+
+ this.context.ICCIOHelper.loadTransparentEF({
+ fileId: ICC_EF_AD,
+ callback: callback.bind(this)
+ });
+ },
+
+ /**
+ * Read the SPN (Service Provider Name) from the (U)SIM.
+ */
+ readSPN: function() {
+ function callback() {
+ let Buf = this.context.Buf;
+ let strLen = Buf.readInt32();
+ // Each octet is encoded into two chars.
+ let octetLen = strLen / 2;
+ let spnDisplayCondition = this.context.GsmPDUHelper.readHexOctet();
+ // Minus 1 because the first octet is used to store display condition.
+ let spn = this.context.ICCPDUHelper.readAlphaIdentifier(octetLen - 1);
+ Buf.readStringDelimiter(strLen);
+
+ if (DEBUG) {
+ this.context.debug("SPN: spn = " + spn +
+ ", spnDisplayCondition = " + spnDisplayCondition);
+ }
+
+ let RIL = this.context.RIL;
+ RIL.iccInfoPrivate.spnDisplayCondition = spnDisplayCondition;
+ RIL.iccInfo.spn = spn;
+ let ICCUtilsHelper = this.context.ICCUtilsHelper;
+ ICCUtilsHelper.updateDisplayCondition();
+ ICCUtilsHelper.handleICCInfoChange();
+ }
+
+ this.context.ICCIOHelper.loadTransparentEF({
+ fileId: ICC_EF_SPN,
+ callback: callback.bind(this)
+ });
+ },
+
+ readIMG: function(recordNumber, onsuccess, onerror) {
+ function callback(options) {
+ let RIL = this.context.RIL;
+ let Buf = this.context.Buf;
+ let GsmPDUHelper = this.context.GsmPDUHelper;
+ let strLen = Buf.readInt32();
+ // Each octet is encoded into two chars.
+ let octetLen = strLen / 2;
+
+ let numInstances = GsmPDUHelper.readHexOctet();
+
+ // Data length is defined as 9n+1 or 9n+2. See TS 31.102, sub-clause
+ // 4.6.1.1. However, it's likely to have padding appended so we have a
+ // rather loose check.
+ if (octetLen < (9 * numInstances + 1)) {
+ Buf.seekIncoming((octetLen - 1) * Buf.PDU_HEX_OCTET_SIZE);
+ Buf.readStringDelimiter(strLen);
+ if (onerror) {
+ onerror();
+ }
+ return;
+ }
+
+ let imgDescriptors = [];
+ for (let i = 0; i < numInstances; i++) {
+ imgDescriptors[i] = {
+ width: GsmPDUHelper.readHexOctet(),
+ height: GsmPDUHelper.readHexOctet(),
+ codingScheme: GsmPDUHelper.readHexOctet(),
+ fileId: (GsmPDUHelper.readHexOctet() << 8) |
+ GsmPDUHelper.readHexOctet(),
+ offset: (GsmPDUHelper.readHexOctet() << 8) |
+ GsmPDUHelper.readHexOctet(),
+ dataLen: (GsmPDUHelper.readHexOctet() << 8) |
+ GsmPDUHelper.readHexOctet()
+ };
+ }
+ Buf.seekIncoming((octetLen - 9 * numInstances - 1) * Buf.PDU_HEX_OCTET_SIZE);
+ Buf.readStringDelimiter(strLen);
+
+ let instances = [];
+ let currentInstance = 0;
+ let readNextInstance = (function(img) {
+ instances[currentInstance] = img;
+ currentInstance++;
+
+ if (currentInstance < numInstances) {
+ let imgDescriptor = imgDescriptors[currentInstance];
+ this.readIIDF(imgDescriptor.fileId,
+ imgDescriptor.offset,
+ imgDescriptor.dataLen,
+ imgDescriptor.codingScheme,
+ readNextInstance,
+ onerror);
+ } else {
+ if (onsuccess) {
+ onsuccess(instances);
+ }
+ }
+ }).bind(this);
+
+ this.readIIDF(imgDescriptors[0].fileId,
+ imgDescriptors[0].offset,
+ imgDescriptors[0].dataLen,
+ imgDescriptors[0].codingScheme,
+ readNextInstance,
+ onerror);
+ }
+
+ this.context.ICCIOHelper.loadLinearFixedEF({
+ fileId: ICC_EF_IMG,
+ recordNumber: recordNumber,
+ callback: callback.bind(this),
+ onerror: onerror
+ });
+ },
+
+ readIIDF: function(fileId, offset, dataLen, codingScheme, onsuccess, onerror) {
+ // Valid fileId is '4FXX', see TS 31.102, clause 4.6.1.2.
+ if ((fileId >> 8) != 0x4F) {
+ if (onerror) {
+ onerror();
+ }
+ return;
+ }
+
+ function callback() {
+ let Buf = this.context.Buf;
+ let RIL = this.context.RIL;
+ let GsmPDUHelper = this.context.GsmPDUHelper;
+ let strLen = Buf.readInt32();
+ // Each octet is encoded into two chars.
+ let octetLen = strLen / 2;
+
+ if (octetLen < offset + dataLen) {
+ // Data length is not enough. See TS 31.102, clause 4.6.1.1, the
+ // paragraph "Bytes 8 and 9: Length of Image Instance Data."
+ Buf.seekIncoming(octetLen * Buf.PDU_HEX_OCTET_SIZE);
+ Buf.readStringDelimiter(strLen);
+ if (onerror) {
+ onerror();
+ }
+ return;
+ }
+
+ Buf.seekIncoming(offset * Buf.PDU_HEX_OCTET_SIZE);
+
+ let rawData = {
+ width: GsmPDUHelper.readHexOctet(),
+ height: GsmPDUHelper.readHexOctet(),
+ codingScheme: codingScheme
+ };
+
+ switch (codingScheme) {
+ case ICC_IMG_CODING_SCHEME_BASIC:
+ rawData.body = GsmPDUHelper.readHexOctetArray(
+ dataLen - ICC_IMG_HEADER_SIZE_BASIC);
+ Buf.seekIncoming((octetLen - offset - dataLen) * Buf.PDU_HEX_OCTET_SIZE);
+ break;
+
+ case ICC_IMG_CODING_SCHEME_COLOR:
+ case ICC_IMG_CODING_SCHEME_COLOR_TRANSPARENCY:
+ rawData.bitsPerImgPoint = GsmPDUHelper.readHexOctet();
+ let num = GsmPDUHelper.readHexOctet();
+ // The value 0 shall be interpreted as 256. See TS 31.102, Annex B.2.
+ rawData.numOfClutEntries = (num === 0) ? 0x100 : num;
+ rawData.clutOffset = (GsmPDUHelper.readHexOctet() << 8) |
+ GsmPDUHelper.readHexOctet();
+ rawData.body = GsmPDUHelper.readHexOctetArray(
+ dataLen - ICC_IMG_HEADER_SIZE_COLOR);
+
+ Buf.seekIncoming((rawData.clutOffset - offset - dataLen) *
+ Buf.PDU_HEX_OCTET_SIZE);
+ let clut = GsmPDUHelper.readHexOctetArray(rawData.numOfClutEntries *
+ ICC_CLUT_ENTRY_SIZE);
+
+ rawData.clut = clut;
+ }
+
+ Buf.readStringDelimiter(strLen);
+
+ if (onsuccess) {
+ onsuccess(rawData);
+ }
+ }
+
+ this.context.ICCIOHelper.loadTransparentEF({
+ fileId: fileId,
+ pathId: this.context.ICCFileHelper.getEFPath(ICC_EF_IMG),
+ callback: callback.bind(this),
+ onerror: onerror
+ });
+ },
+
+ /**
+ * Read the (U)SIM Service Table from the (U)SIM.
+ */
+ readSST: function() {
+ function callback() {
+ let Buf = this.context.Buf;
+ let RIL = this.context.RIL;
+
+ let strLen = Buf.readInt32();
+ // Each octet is encoded into two chars.
+ let octetLen = strLen / 2;
+ let sst = this.context.GsmPDUHelper.readHexOctetArray(octetLen);
+ Buf.readStringDelimiter(strLen);
+ RIL.iccInfoPrivate.sst = sst;
+ if (DEBUG) {
+ let str = "";
+ for (let i = 0; i < sst.length; i++) {
+ str += sst[i] + ", ";
+ }
+ this.context.debug("SST: " + str);
+ }
+
+ let ICCUtilsHelper = this.context.ICCUtilsHelper;
+ if (ICCUtilsHelper.isICCServiceAvailable("MSISDN")) {
+ if (DEBUG) this.context.debug("MSISDN: MSISDN is available");
+ this.readMSISDN();
+ } else {
+ if (DEBUG) this.context.debug("MSISDN: MSISDN service is not available");
+ }
+
+ // Fetch SPN and PLMN list, if some of them are available.
+ if (ICCUtilsHelper.isICCServiceAvailable("SPN")) {
+ if (DEBUG) this.context.debug("SPN: SPN is available");
+ this.readSPN();
+ } else {
+ if (DEBUG) this.context.debug("SPN: SPN service is not available");
+ }
+
+ if (ICCUtilsHelper.isICCServiceAvailable("MDN")) {
+ if (DEBUG) this.context.debug("MDN: MDN available.");
+ this.readMBDN();
+ } else {
+ if (DEBUG) this.context.debug("MDN: MDN service is not available");
+
+ if (ICCUtilsHelper.isCphsServiceAvailable("MBN")) {
+ // read CPHS_MBN in advance if MBDN is not available.
+ this.readCphsMBN();
+ } else {
+ if (DEBUG) this.context.debug("CPHS_MBN: CPHS_MBN service is not available");
+ }
+ }
+
+ if (ICCUtilsHelper.isICCServiceAvailable("MWIS")) {
+ if (DEBUG) this.context.debug("MWIS: MWIS is available");
+ this.readMWIS();
+ } else {
+ if (DEBUG) this.context.debug("MWIS: MWIS is not available");
+ }
+
+ if (ICCUtilsHelper.isICCServiceAvailable("SPDI")) {
+ if (DEBUG) this.context.debug("SPDI: SPDI available.");
+ this.readSPDI();
+ } else {
+ if (DEBUG) this.context.debug("SPDI: SPDI service is not available");
+ }
+
+ if (ICCUtilsHelper.isICCServiceAvailable("PNN")) {
+ if (DEBUG) this.context.debug("PNN: PNN is available");
+ this.readPNN();
+ } else {
+ if (DEBUG) this.context.debug("PNN: PNN is not available");
+ }
+
+ if (ICCUtilsHelper.isICCServiceAvailable("OPL")) {
+ if (DEBUG) this.context.debug("OPL: OPL is available");
+ this.readOPL();
+ } else {
+ if (DEBUG) this.context.debug("OPL: OPL is not available");
+ }
+
+ if (ICCUtilsHelper.isICCServiceAvailable("GID1")) {
+ if (DEBUG) this.context.debug("GID1: GID1 is available");
+ this.readGID1();
+ } else {
+ if (DEBUG) this.context.debug("GID1: GID1 is not available");
+ }
+
+ if (ICCUtilsHelper.isICCServiceAvailable("CBMI")) {
+ this.readCBMI();
+ } else {
+ RIL.cellBroadcastConfigs.CBMI = null;
+ }
+ if (ICCUtilsHelper.isICCServiceAvailable("DATA_DOWNLOAD_SMS_CB")) {
+ this.readCBMID();
+ } else {
+ RIL.cellBroadcastConfigs.CBMID = null;
+ }
+ if (ICCUtilsHelper.isICCServiceAvailable("CBMIR")) {
+ this.readCBMIR();
+ } else {
+ RIL.cellBroadcastConfigs.CBMIR = null;
+ }
+ RIL._mergeAllCellBroadcastConfigs();
+ }
+
+ // ICC_EF_UST has the same value with ICC_EF_SST.
+ this.context.ICCIOHelper.loadTransparentEF({
+ fileId: ICC_EF_SST,
+ callback: callback.bind(this)
+ });
+ },
+
+ /**
+ * Read (U)SIM MBDN. (Mailbox Dialling Number)
+ *
+ * @see TS 131.102, clause 4.2.60
+ */
+ readMBDN: function() {
+ function callback(options) {
+ let RIL = this.context.RIL;
+ let contact =
+ this.context.ICCPDUHelper.readAlphaIdDiallingNumber(options.recordSize);
+ if ((!contact ||
+ ((!contact.alphaId || contact.alphaId == "") &&
+ (!contact.number || contact.number == ""))) &&
+ this.context.ICCUtilsHelper.isCphsServiceAvailable("MBN")) {
+ // read CPHS_MBN in advance if MBDN is invalid or empty.
+ this.readCphsMBN();
+ return;
+ }
+
+ if (!contact ||
+ (RIL.iccInfoPrivate.mbdn !== undefined &&
+ RIL.iccInfoPrivate.mbdn === contact.number)) {
+ return;
+ }
+ RIL.iccInfoPrivate.mbdn = contact.number;
+ if (DEBUG) {
+ this.context.debug("MBDN, alphaId=" + contact.alphaId +
+ " number=" + contact.number);
+ }
+ contact.rilMessageType = "iccmbdn";
+ RIL.sendChromeMessage(contact);
+ }
+
+ this.context.ICCIOHelper.loadLinearFixedEF({
+ fileId: ICC_EF_MBDN,
+ callback: callback.bind(this)
+ });
+ },
+
+ /**
+ * Read ICC MWIS. (Message Waiting Indication Status)
+ *
+ * @see TS 31.102, clause 4.2.63 for USIM and TS 51.011, clause 10.3.45 for SIM.
+ */
+ readMWIS: function() {
+ function callback(options) {
+ let Buf = this.context.Buf;
+ let RIL = this.context.RIL;
+
+ let strLen = Buf.readInt32();
+ // Each octet is encoded into two chars.
+ let octetLen = strLen / 2;
+ let mwis = this.context.GsmPDUHelper.readHexOctetArray(octetLen);
+ Buf.readStringDelimiter(strLen);
+ if (!mwis) {
+ return;
+ }
+ RIL.iccInfoPrivate.mwis = mwis; //Keep raw MWIS for updateMWIS()
+
+ let mwi = {};
+ // b8 b7 B6 b5 b4 b3 b2 b1 4.2.63, TS 31.102 version 11.6.0
+ // | | | | | | | |__ Voicemail
+ // | | | | | | |_____ Fax
+ // | | | | | |________ Electronic Mail
+ // | | | | |___________ Other
+ // | | | |______________ Videomail
+ // |__|__|_________________ RFU
+ mwi.active = ((mwis[0] & 0x01) != 0);
+
+ if (mwi.active) {
+ // In TS 23.040 msgCount is in the range from 0 to 255.
+ // The value 255 shall be taken to mean 255 or greater.
+ //
+ // However, There is no definition about 0 when MWI is active.
+ //
+ // Normally, when mwi is active, the msgCount must be larger than 0.
+ // Refer to other reference phone,
+ // 0 is usually treated as UNKNOWN for storing 2nd level MWI status (DCS).
+ mwi.msgCount = (mwis[1] === 0) ? GECKO_VOICEMAIL_MESSAGE_COUNT_UNKNOWN
+ : mwis[1];
+ } else {
+ mwi.msgCount = 0;
+ }
+
+ RIL.sendChromeMessage({ rilMessageType: "iccmwis",
+ mwi: mwi });
+ }
+
+ this.context.ICCIOHelper.loadLinearFixedEF({
+ fileId: ICC_EF_MWIS,
+ recordNumber: 1, // Get 1st Subscriber Profile.
+ callback: callback.bind(this)
+ });
+ },
+
+ /**
+ * Update ICC MWIS. (Message Waiting Indication Status)
+ *
+ * @see TS 31.102, clause 4.2.63 for USIM and TS 51.011, clause 10.3.45 for SIM.
+ */
+ updateMWIS: function(mwi) {
+ let RIL = this.context.RIL;
+ if (!RIL.iccInfoPrivate.mwis) {
+ return;
+ }
+
+ function dataWriter(recordSize) {
+ let mwis = RIL.iccInfoPrivate.mwis;
+
+ let msgCount =
+ (mwi.msgCount === GECKO_VOICEMAIL_MESSAGE_COUNT_UNKNOWN) ? 0 : mwi.msgCount;
+
+ [mwis[0], mwis[1]] = (mwi.active) ? [(mwis[0] | 0x01), msgCount]
+ : [(mwis[0] & 0xFE), 0];
+
+ let strLen = recordSize * 2;
+ let Buf = this.context.Buf;
+ Buf.writeInt32(strLen);
+
+ let GsmPDUHelper = this.context.GsmPDUHelper;
+ for (let i = 0; i < mwis.length; i++) {
+ GsmPDUHelper.writeHexOctet(mwis[i]);
+ }
+
+ Buf.writeStringDelimiter(strLen);
+ }
+
+ this.context.ICCIOHelper.updateLinearFixedEF({
+ fileId: ICC_EF_MWIS,
+ recordNumber: 1, // Update 1st Subscriber Profile.
+ dataWriter: dataWriter.bind(this)
+ });
+ },
+
+ /**
+ * Read the SPDI (Service Provider Display Information) from the (U)SIM.
+ *
+ * See TS 131.102 section 4.2.66 for USIM and TS 51.011 section 10.3.50
+ * for SIM.
+ */
+ readSPDI: function() {
+ function callback() {
+ let Buf = this.context.Buf;
+ let strLen = Buf.readInt32();
+ let octetLen = strLen / 2;
+ let readLen = 0;
+ let endLoop = false;
+
+ let RIL = this.context.RIL;
+ RIL.iccInfoPrivate.SPDI = null;
+
+ let GsmPDUHelper = this.context.GsmPDUHelper;
+ while ((readLen < octetLen) && !endLoop) {
+ let tlvTag = GsmPDUHelper.readHexOctet();
+ let tlvLen = GsmPDUHelper.readHexOctet();
+ readLen += 2; // For tag and length fields.
+ switch (tlvTag) {
+ case SPDI_TAG_SPDI:
+ // The value part itself is a TLV.
+ continue;
+ case SPDI_TAG_PLMN_LIST:
+ // This PLMN list is what we want.
+ RIL.iccInfoPrivate.SPDI = this.readPLMNEntries(tlvLen / 3);
+ readLen += tlvLen;
+ endLoop = true;
+ break;
+ default:
+ // We don't care about its content if its tag is not SPDI nor
+ // PLMN_LIST.
+ endLoop = true;
+ break;
+ }
+ }
+
+ // Consume unread octets.
+ Buf.seekIncoming((octetLen - readLen) * Buf.PDU_HEX_OCTET_SIZE);
+ Buf.readStringDelimiter(strLen);
+
+ if (DEBUG) {
+ this.context.debug("SPDI: " + JSON.stringify(RIL.iccInfoPrivate.SPDI));
+ }
+ let ICCUtilsHelper = this.context.ICCUtilsHelper;
+ if (ICCUtilsHelper.updateDisplayCondition()) {
+ ICCUtilsHelper.handleICCInfoChange();
+ }
+ }
+
+ // PLMN List is Servive 51 in USIM, EF_SPDI
+ this.context.ICCIOHelper.loadTransparentEF({
+ fileId: ICC_EF_SPDI,
+ callback: callback.bind(this)
+ });
+ },
+
+ _readCbmiHelper: function(which) {
+ let RIL = this.context.RIL;
+
+ function callback() {
+ let Buf = this.context.Buf;
+ let strLength = Buf.readInt32();
+
+ // Each Message Identifier takes two octets and each octet is encoded
+ // into two chars.
+ let numIds = strLength / 4, list = null;
+ if (numIds) {
+ list = [];
+ let GsmPDUHelper = this.context.GsmPDUHelper;
+ for (let i = 0, id; i < numIds; i++) {
+ id = GsmPDUHelper.readHexOctet() << 8 | GsmPDUHelper.readHexOctet();
+ // `Unused entries shall be set to 'FF FF'.`
+ if (id != 0xFFFF) {
+ list.push(id);
+ list.push(id + 1);
+ }
+ }
+ }
+ if (DEBUG) {
+ this.context.debug(which + ": " + JSON.stringify(list));
+ }
+
+ Buf.readStringDelimiter(strLength);
+
+ RIL.cellBroadcastConfigs[which] = list;
+ RIL._mergeAllCellBroadcastConfigs();
+ }
+
+ function onerror() {
+ RIL.cellBroadcastConfigs[which] = null;
+ RIL._mergeAllCellBroadcastConfigs();
+ }
+
+ let fileId = GLOBAL["ICC_EF_" + which];
+ this.context.ICCIOHelper.loadTransparentEF({
+ fileId: fileId,
+ callback: callback.bind(this),
+ onerror: onerror.bind(this)
+ });
+ },
+
+ /**
+ * Read EFcbmi (Cell Broadcast Message Identifier selection)
+ *
+ * @see 3GPP TS 31.102 v110.02.0 section 4.2.14 EFcbmi
+ * @see 3GPP TS 51.011 v5.0.0 section 10.3.13 EFcbmi
+ */
+ readCBMI: function() {
+ this._readCbmiHelper("CBMI");
+ },
+
+ /**
+ * Read EFcbmid (Cell Broadcast Message Identifier for Data Download)
+ *
+ * @see 3GPP TS 31.102 v110.02.0 section 4.2.20 EFcbmid
+ * @see 3GPP TS 51.011 v5.0.0 section 10.3.26 EFcbmid
+ */
+ readCBMID: function() {
+ this._readCbmiHelper("CBMID");
+ },
+
+ /**
+ * Read EFcbmir (Cell Broadcast Message Identifier Range selection)
+ *
+ * @see 3GPP TS 31.102 v110.02.0 section 4.2.22 EFcbmir
+ * @see 3GPP TS 51.011 v5.0.0 section 10.3.28 EFcbmir
+ */
+ readCBMIR: function() {
+ let RIL = this.context.RIL;
+
+ function callback() {
+ let Buf = this.context.Buf;
+ let strLength = Buf.readInt32();
+
+ // Each Message Identifier range takes four octets and each octet is
+ // encoded into two chars.
+ let numIds = strLength / 8, list = null;
+ if (numIds) {
+ list = [];
+ let GsmPDUHelper = this.context.GsmPDUHelper;
+ for (let i = 0, from, to; i < numIds; i++) {
+ // `Bytes one and two of each range identifier equal the lower value
+ // of a cell broadcast range, bytes three and four equal the upper
+ // value of a cell broadcast range.`
+ from = GsmPDUHelper.readHexOctet() << 8 | GsmPDUHelper.readHexOctet();
+ to = GsmPDUHelper.readHexOctet() << 8 | GsmPDUHelper.readHexOctet();
+ // `Unused entries shall be set to 'FF FF'.`
+ if ((from != 0xFFFF) && (to != 0xFFFF)) {
+ list.push(from);
+ list.push(to + 1);
+ }
+ }
+ }
+ if (DEBUG) {
+ this.context.debug("CBMIR: " + JSON.stringify(list));
+ }
+
+ Buf.readStringDelimiter(strLength);
+
+ RIL.cellBroadcastConfigs.CBMIR = list;
+ RIL._mergeAllCellBroadcastConfigs();
+ }
+
+ function onerror() {
+ RIL.cellBroadcastConfigs.CBMIR = null;
+ RIL._mergeAllCellBroadcastConfigs();
+ }
+
+ this.context.ICCIOHelper.loadTransparentEF({
+ fileId: ICC_EF_CBMIR,
+ callback: callback.bind(this),
+ onerror: onerror.bind(this)
+ });
+ },
+
+ /**
+ * Read OPL (Operator PLMN List) from (U)SIM.
+ *
+ * See 3GPP TS 31.102 Sec. 4.2.59 for USIM
+ * 3GPP TS 51.011 Sec. 10.3.42 for SIM.
+ */
+ readOPL: function() {
+ let ICCIOHelper = this.context.ICCIOHelper;
+ let opl = [];
+ function callback(options) {
+ let Buf = this.context.Buf;
+ let GsmPDUHelper = this.context.GsmPDUHelper;
+
+ let strLen = Buf.readInt32();
+ // The first 7 bytes are LAI (for UMTS) and the format of LAI is defined
+ // in 3GPP TS 23.003, Sec 4.1
+ // +-------------+---------+
+ // | Octet 1 - 3 | MCC/MNC |
+ // +-------------+---------+
+ // | Octet 4 - 7 | LAC |
+ // +-------------+---------+
+ let mccMnc = [GsmPDUHelper.readHexOctet(),
+ GsmPDUHelper.readHexOctet(),
+ GsmPDUHelper.readHexOctet()];
+ if (mccMnc[0] != 0xFF || mccMnc[1] != 0xFF || mccMnc[2] != 0xFF) {
+ let oplElement = {};
+ let semiOctets = [];
+ for (let i = 0; i < mccMnc.length; i++) {
+ semiOctets.push((mccMnc[i] & 0xf0) >> 4);
+ semiOctets.push(mccMnc[i] & 0x0f);
+ }
+ let reformat = [semiOctets[1], semiOctets[0], semiOctets[3],
+ semiOctets[5], semiOctets[4], semiOctets[2]];
+ let buf = "";
+ for (let i = 0; i < reformat.length; i++) {
+ if (reformat[i] != 0xF) {
+ buf += GsmPDUHelper.semiOctetToExtendedBcdChar(reformat[i]);
+ }
+ if (i === 2) {
+ // 0-2: MCC
+ oplElement.mcc = buf;
+ buf = "";
+ } else if (i === 5) {
+ // 3-5: MNC
+ oplElement.mnc = buf;
+ }
+ }
+ // LAC/TAC
+ oplElement.lacTacStart =
+ (GsmPDUHelper.readHexOctet() << 8) | GsmPDUHelper.readHexOctet();
+ oplElement.lacTacEnd =
+ (GsmPDUHelper.readHexOctet() << 8) | GsmPDUHelper.readHexOctet();
+ // PLMN Network Name Record Identifier
+ oplElement.pnnRecordId = GsmPDUHelper.readHexOctet();
+ if (DEBUG) {
+ this.context.debug("OPL: [" + (opl.length + 1) + "]: " +
+ JSON.stringify(oplElement));
+ }
+ opl.push(oplElement);
+ } else {
+ Buf.seekIncoming(5 * Buf.PDU_HEX_OCTET_SIZE);
+ }
+ Buf.readStringDelimiter(strLen);
+
+ let RIL = this.context.RIL;
+ if (options.p1 < options.totalRecords) {
+ ICCIOHelper.loadNextRecord(options);
+ } else {
+ RIL.iccInfoPrivate.OPL = opl;
+ RIL.overrideICCNetworkName();
+ }
+ }
+
+ ICCIOHelper.loadLinearFixedEF({fileId: ICC_EF_OPL,
+ callback: callback.bind(this)});
+ },
+
+ /**
+ * Read PNN (PLMN Network Name) from (U)SIM.
+ *
+ * See 3GPP TS 31.102 Sec. 4.2.58 for USIM
+ * 3GPP TS 51.011 Sec. 10.3.41 for SIM.
+ */
+ readPNN: function() {
+ let ICCIOHelper = this.context.ICCIOHelper;
+ function callback(options) {
+ let pnnElement;
+ let Buf = this.context.Buf;
+ let strLen = Buf.readInt32();
+ let octetLen = strLen / 2;
+ let readLen = 0;
+
+ let GsmPDUHelper = this.context.GsmPDUHelper;
+ while (readLen < octetLen) {
+ let tlvTag = GsmPDUHelper.readHexOctet();
+
+ if (tlvTag == 0xFF) {
+ // Unused byte
+ readLen++;
+ Buf.seekIncoming((octetLen - readLen) * Buf.PDU_HEX_OCTET_SIZE);
+ break;
+ }
+
+ // Needs this check to avoid initializing twice.
+ pnnElement = pnnElement || {};
+
+ let tlvLen = GsmPDUHelper.readHexOctet();
+
+ switch (tlvTag) {
+ case PNN_IEI_FULL_NETWORK_NAME:
+ pnnElement.fullName = GsmPDUHelper.readNetworkName(tlvLen);
+ break;
+ case PNN_IEI_SHORT_NETWORK_NAME:
+ pnnElement.shortName = GsmPDUHelper.readNetworkName(tlvLen);
+ break;
+ default:
+ Buf.seekIncoming(tlvLen * Buf.PDU_HEX_OCTET_SIZE);
+ break;
+ }
+
+ readLen += (tlvLen + 2); // +2 for tlvTag and tlvLen
+ }
+ Buf.readStringDelimiter(strLen);
+
+ pnn.push(pnnElement);
+
+ let RIL = this.context.RIL;
+ if (options.p1 < options.totalRecords) {
+ ICCIOHelper.loadNextRecord(options);
+ } else {
+ if (DEBUG) {
+ for (let i = 0; i < pnn.length; i++) {
+ this.context.debug("PNN: [" + i + "]: " + JSON.stringify(pnn[i]));
+ }
+ }
+ RIL.iccInfoPrivate.PNN = pnn;
+ RIL.overrideICCNetworkName();
+ }
+ }
+
+ let pnn = [];
+ ICCIOHelper.loadLinearFixedEF({fileId: ICC_EF_PNN,
+ callback: callback.bind(this)});
+ },
+
+ /**
+ * Read the list of PLMN (Public Land Mobile Network) entries
+ * We cannot directly rely on readSwappedNibbleBcdToString(),
+ * since it will no correctly handle some corner-cases that are
+ * not a problem in our case (0xFF 0xFF 0xFF).
+ *
+ * @param length The number of PLMN records.
+ * @return An array of string corresponding to the PLMNs.
+ */
+ readPLMNEntries: function(length) {
+ let plmnList = [];
+ // Each PLMN entry has 3 bytes.
+ if (DEBUG) {
+ this.context.debug("PLMN entries length = " + length);
+ }
+ let GsmPDUHelper = this.context.GsmPDUHelper;
+ let index = 0;
+ while (index < length) {
+ // Unused entries will be 0xFFFFFF, according to EF_SPDI
+ // specs (TS 131 102, section 4.2.66)
+ try {
+ let plmn = [GsmPDUHelper.readHexOctet(),
+ GsmPDUHelper.readHexOctet(),
+ GsmPDUHelper.readHexOctet()];
+ if (DEBUG) {
+ this.context.debug("Reading PLMN entry: [" + index + "]: '" + plmn + "'");
+ }
+ if (plmn[0] != 0xFF &&
+ plmn[1] != 0xFF &&
+ plmn[2] != 0xFF) {
+ let semiOctets = [];
+ for (let idx = 0; idx < plmn.length; idx++) {
+ semiOctets.push((plmn[idx] & 0xF0) >> 4);
+ semiOctets.push(plmn[idx] & 0x0F);
+ }
+
+ // According to TS 24.301, 9.9.3.12, the semi octets is arranged
+ // in format:
+ // Byte 1: MCC[2] | MCC[1]
+ // Byte 2: MNC[3] | MCC[3]
+ // Byte 3: MNC[2] | MNC[1]
+ // Therefore, we need to rearrange them.
+ let reformat = [semiOctets[1], semiOctets[0], semiOctets[3],
+ semiOctets[5], semiOctets[4], semiOctets[2]];
+ let buf = "";
+ let plmnEntry = {};
+ for (let i = 0; i < reformat.length; i++) {
+ if (reformat[i] != 0xF) {
+ buf += GsmPDUHelper.semiOctetToExtendedBcdChar(reformat[i]);
+ }
+ if (i === 2) {
+ // 0-2: MCC
+ plmnEntry.mcc = buf;
+ buf = "";
+ } else if (i === 5) {
+ // 3-5: MNC
+ plmnEntry.mnc = buf;
+ }
+ }
+ if (DEBUG) {
+ this.context.debug("PLMN = " + plmnEntry.mcc + ", " + plmnEntry.mnc);
+ }
+ plmnList.push(plmnEntry);
+ }
+ } catch (e) {
+ if (DEBUG) {
+ this.context.debug("PLMN entry " + index + " is invalid.");
+ }
+ break;
+ }
+ index ++;
+ }
+ return plmnList;
+ },
+
+ /**
+ * Read the SMS from the ICC.
+ *
+ * @param recordNumber The number of the record shall be loaded.
+ * @param onsuccess Callback to be called when success.
+ * @param onerror Callback to be called when error.
+ */
+ readSMS: function(recordNumber, onsuccess, onerror) {
+ function callback(options) {
+ let Buf = this.context.Buf;
+ let strLen = Buf.readInt32();
+
+ // TS 51.011, 10.5.3 EF_SMS
+ // b3 b2 b1
+ // 0 0 1 message received by MS from network; message read
+ // 0 1 1 message received by MS from network; message to be read
+ // 1 1 1 MS originating message; message to be sent
+ // 1 0 1 MS originating message; message sent to the network:
+ let GsmPDUHelper = this.context.GsmPDUHelper;
+ let status = GsmPDUHelper.readHexOctet();
+
+ let message = GsmPDUHelper.readMessage();
+ message.simStatus = status;
+
+ // Consumes the remaining buffer
+ Buf.seekIncoming(Buf.getReadAvailable() - Buf.PDU_HEX_OCTET_SIZE);
+
+ Buf.readStringDelimiter(strLen);
+
+ if (message) {
+ onsuccess(message);
+ } else {
+ onerror("Failed to decode SMS on SIM #" + recordNumber);
+ }
+ }
+
+ this.context.ICCIOHelper.loadLinearFixedEF({
+ fileId: ICC_EF_SMS,
+ recordNumber: recordNumber,
+ callback: callback.bind(this),
+ onerror: onerror
+ });
+ },
+
+ readGID1: function() {
+ function callback() {
+ let Buf = this.context.Buf;
+ let RIL = this.context.RIL;
+
+ RIL.iccInfoPrivate.gid1 = Buf.readString();
+ if (DEBUG) {
+ this.context.debug("GID1: " + RIL.iccInfoPrivate.gid1);
+ }
+ }
+
+ this.context.ICCIOHelper.loadTransparentEF({
+ fileId: ICC_EF_GID1,
+ callback: callback.bind(this)
+ });
+ },
+
+ /**
+ * Read CPHS Phase & Service Table from CPHS Info.
+ *
+ * @See B.3.1.1 CPHS Information in CPHS Phase 2.
+ *
+ * @param onsuccess Callback to be called when success.
+ * @param onerror Callback to be called when error.
+ */
+ readCphsInfo: function(onsuccess, onerror) {
+ function callback() {
+ try {
+ let Buf = this.context.Buf;
+ let RIL = this.context.RIL;
+
+ let strLen = Buf.readInt32();
+ // Each octet is encoded into two chars.
+ let octetLen = strLen / 2;
+ let cphsInfo = this.context.GsmPDUHelper.readHexOctetArray(octetLen);
+ Buf.readStringDelimiter(strLen);
+ if (DEBUG) {
+ let str = "";
+ for (let i = 0; i < cphsInfo.length; i++) {
+ str += cphsInfo[i] + ", ";
+ }
+ this.context.debug("CPHS INFO: " + str);
+ }
+
+ /**
+ * CPHS INFORMATION
+ *
+ * Byte 1: CPHS Phase
+ * 01 phase 1
+ * 02 phase 2
+ * etc.
+ *
+ * Byte 2: CPHS Service Table
+ * +----+----+----+----+----+----+----+----+
+ * | b8 | b7 | b6 | b5 | b4 | b3 | b2 | b1 |
+ * +----+----+----+----+----+----+----+----+
+ * | ONSF | MBN | SST | CSP |
+ * | Phase 2 | ALL | Phase 1 | All |
+ * +----+----+----+----+----+----+----+----+
+ *
+ * Byte 3: CPHS Service Table continued
+ * +----+----+----+----+----+----+----+----+
+ * | b8 | b7 | b6 | b5 | b4 | b3 | b2 | b1 |
+ * +----+----+----+----+----+----+----+----+
+ * | RFU | RFU | RFU | INFO_NUM|
+ * | | | | Phase 2 |
+ * +----+----+----+----+----+----+----+----+
+ */
+ let cphsPhase = cphsInfo[0];
+ if (cphsPhase == 1) {
+ // Clear 'Phase 2 only' services.
+ cphsInfo[1] &= 0x3F;
+ // We don't know whether Byte 3 is available in CPHS phase 1 or not.
+ // Add boundary check before accessing it.
+ if (cphsInfo.length > 2) {
+ cphsInfo[2] = 0x00;
+ }
+ } else if (cphsPhase == 2) {
+ // Clear 'Phase 1 only' services.
+ cphsInfo[1] &= 0xF3;
+ } else {
+ throw new Error("Unknown CPHS phase: " + cphsPhase);
+ }
+
+ RIL.iccInfoPrivate.cphsSt = cphsInfo.subarray(1);
+ onsuccess();
+ } catch(e) {
+ onerror(e.toString());
+ }
+ }
+
+ this.context.ICCIOHelper.loadTransparentEF({
+ fileId: ICC_EF_CPHS_INFO,
+ callback: callback.bind(this),
+ onerror: onerror
+ });
+ },
+
+ /**
+ * Read CPHS MBN. (Mailbox Numbers)
+ *
+ * @See B.4.2.2 Voice Message Retrieval and Indicator Clearing
+ */
+ readCphsMBN: function() {
+ function callback(options) {
+ let RIL = this.context.RIL;
+ let contact =
+ this.context.ICCPDUHelper.readAlphaIdDiallingNumber(options.recordSize);
+ if (!contact ||
+ (RIL.iccInfoPrivate.mbdn !== undefined &&
+ RIL.iccInfoPrivate.mbdn === contact.number)) {
+ return;
+ }
+ RIL.iccInfoPrivate.mbdn = contact.number;
+ if (DEBUG) {
+ this.context.debug("CPHS_MDN, alphaId=" + contact.alphaId +
+ " number=" + contact.number);
+ }
+ contact.rilMessageType = "iccmbdn";
+ RIL.sendChromeMessage(contact);
+ }
+
+ this.context.ICCIOHelper.loadLinearFixedEF({
+ fileId: ICC_EF_CPHS_MBN,
+ callback: callback.bind(this)
+ });
+ }
+};
+
+function RuimRecordHelperObject(aContext) {
+ this.context = aContext;
+}
+RuimRecordHelperObject.prototype = {
+ context: null,
+
+ fetchRuimRecords: function() {
+ this.getIMSI_M();
+ this.readCST();
+ this.readCDMAHome();
+ this.context.RIL.getCdmaSubscription();
+ },
+
+ /**
+ * Get IMSI_M from CSIM/RUIM.
+ * See 3GPP2 C.S0065 Sec. 5.2.2
+ */
+ getIMSI_M: function() {
+ function callback() {
+ let Buf = this.context.Buf;
+ let strLen = Buf.readInt32();
+ let encodedImsi = this.context.GsmPDUHelper.readHexOctetArray(strLen / 2);
+ Buf.readStringDelimiter(strLen);
+
+ if ((encodedImsi[CSIM_IMSI_M_PROGRAMMED_BYTE] & 0x80)) { // IMSI_M programmed
+ let RIL = this.context.RIL;
+ RIL.iccInfoPrivate.imsi = this.decodeIMSI(encodedImsi);
+ RIL.sendChromeMessage({rilMessageType: "iccimsi",
+ imsi: RIL.iccInfoPrivate.imsi});
+
+ let ICCUtilsHelper = this.context.ICCUtilsHelper;
+ let mccMnc = ICCUtilsHelper.parseMccMncFromImsi(RIL.iccInfoPrivate.imsi);
+ if (mccMnc) {
+ RIL.iccInfo.mcc = mccMnc.mcc;
+ RIL.iccInfo.mnc = mccMnc.mnc;
+ ICCUtilsHelper.handleICCInfoChange();
+ }
+ }
+ }
+
+ this.context.ICCIOHelper.loadTransparentEF({
+ fileId: ICC_EF_CSIM_IMSI_M,
+ callback: callback.bind(this)
+ });
+ },
+
+ /**
+ * Decode IMSI from IMSI_M
+ * See 3GPP2 C.S0005 Sec. 2.3.1
+ * +---+---------+------------+---+--------+---------+---+---------+--------+
+ * |RFU| MCC | programmed |RFU| MNC | MIN1 |RFU| MIN2 | CLASS |
+ * +---+---------+------------+---+--------+---------+---+---------+--------+
+ * | 6 | 10 bits | 8 bits | 1 | 7 bits | 24 bits | 6 | 10 bits | 8 bits |
+ * +---+---------+------------+---+--------+---------+---+---------+--------+
+ */
+ decodeIMSI: function(encodedImsi) {
+ // MCC: 10 bits, 3 digits
+ let encodedMCC = ((encodedImsi[CSIM_IMSI_M_MCC_BYTE + 1] & 0x03) << 8) +
+ (encodedImsi[CSIM_IMSI_M_MCC_BYTE] & 0xff);
+ let mcc = this.decodeIMSIValue(encodedMCC, 3);
+
+ // MNC: 7 bits, 2 digits
+ let encodedMNC = encodedImsi[CSIM_IMSI_M_MNC_BYTE] & 0x7f;
+ let mnc = this.decodeIMSIValue(encodedMNC, 2);
+
+ // MIN2: 10 bits, 3 digits
+ let encodedMIN2 = ((encodedImsi[CSIM_IMSI_M_MIN2_BYTE + 1] & 0x03) << 8) +
+ (encodedImsi[CSIM_IMSI_M_MIN2_BYTE] & 0xff);
+ let min2 = this.decodeIMSIValue(encodedMIN2, 3);
+
+ // MIN1: 10+4+10 bits, 3+1+3 digits
+ let encodedMIN1First3 = ((encodedImsi[CSIM_IMSI_M_MIN1_BYTE + 2] & 0xff) << 2) +
+ ((encodedImsi[CSIM_IMSI_M_MIN1_BYTE + 1] & 0xc0) >> 6);
+ let min1First3 = this.decodeIMSIValue(encodedMIN1First3, 3);
+
+ let encodedFourthDigit = (encodedImsi[CSIM_IMSI_M_MIN1_BYTE + 1] & 0x3c) >> 2;
+ if (encodedFourthDigit > 9) {
+ encodedFourthDigit = 0;
+ }
+ let fourthDigit = encodedFourthDigit.toString();
+
+ let encodedMIN1Last3 = ((encodedImsi[CSIM_IMSI_M_MIN1_BYTE + 1] & 0x03) << 8) +
+ (encodedImsi[CSIM_IMSI_M_MIN1_BYTE] & 0xff);
+ let min1Last3 = this.decodeIMSIValue(encodedMIN1Last3, 3);
+
+ return mcc + mnc + min2 + min1First3 + fourthDigit + min1Last3;
+ },
+
+ /**
+ * Decode IMSI Helper function
+ * See 3GPP2 C.S0005 section 2.3.1.1
+ */
+ decodeIMSIValue: function(encoded, length) {
+ let offset = length === 3 ? 111 : 11;
+ let value = encoded + offset;
+
+ for (let base = 10, temp = value, i = 0; i < length; i++) {
+ if (temp % 10 === 0) {
+ value -= base;
+ }
+ temp = Math.floor(value / base);
+ base = base * 10;
+ }
+
+ let s = value.toString();
+ while (s.length < length) {
+ s = "0" + s;
+ }
+
+ return s;
+ },
+
+ /**
+ * Read CDMAHOME for CSIM.
+ * See 3GPP2 C.S0023 Sec. 3.4.8.
+ */
+ readCDMAHome: function() {
+ let ICCIOHelper = this.context.ICCIOHelper;
+
+ function callback(options) {
+ let Buf = this.context.Buf;
+ let GsmPDUHelper = this.context.GsmPDUHelper;
+
+ let strLen = Buf.readInt32();
+ let tempOctet = GsmPDUHelper.readHexOctet();
+ cdmaHomeSystemId.push(((GsmPDUHelper.readHexOctet() & 0x7f) << 8) | tempOctet);
+ tempOctet = GsmPDUHelper.readHexOctet();
+ cdmaHomeNetworkId.push(((GsmPDUHelper.readHexOctet() & 0xff) << 8) | tempOctet);
+
+ // Consuming the last octet: band class.
+ Buf.seekIncoming(Buf.PDU_HEX_OCTET_SIZE);
+
+ Buf.readStringDelimiter(strLen);
+ if (options.p1 < options.totalRecords) {
+ ICCIOHelper.loadNextRecord(options);
+ } else {
+ if (DEBUG) {
+ this.context.debug("CDMAHome system id: " +
+ JSON.stringify(cdmaHomeSystemId));
+ this.context.debug("CDMAHome network id: " +
+ JSON.stringify(cdmaHomeNetworkId));
+ }
+ this.context.RIL.cdmaHome = {
+ systemId: cdmaHomeSystemId,
+ networkId: cdmaHomeNetworkId
+ };
+ }
+ }
+
+ let cdmaHomeSystemId = [], cdmaHomeNetworkId = [];
+ ICCIOHelper.loadLinearFixedEF({fileId: ICC_EF_CSIM_CDMAHOME,
+ callback: callback.bind(this)});
+ },
+
+ /**
+ * Read CDMA Service Table.
+ * See 3GPP2 C.S0023 Sec. 3.4.18
+ */
+ readCST: function() {
+ function callback() {
+ let Buf = this.context.Buf;
+ let RIL = this.context.RIL;
+
+ let strLen = Buf.readInt32();
+ // Each octet is encoded into two chars.
+ RIL.iccInfoPrivate.cst =
+ this.context.GsmPDUHelper.readHexOctetArray(strLen / 2);
+ Buf.readStringDelimiter(strLen);
+
+ if (DEBUG) {
+ let str = "";
+ for (let i = 0; i < RIL.iccInfoPrivate.cst.length; i++) {
+ str += RIL.iccInfoPrivate.cst[i] + ", ";
+ }
+ this.context.debug("CST: " + str);
+ }
+
+ if (this.context.ICCUtilsHelper.isICCServiceAvailable("SPN")) {
+ if (DEBUG) this.context.debug("SPN: SPN is available");
+ this.readSPN();
+ }
+ }
+ this.context.ICCIOHelper.loadTransparentEF({
+ fileId: ICC_EF_CSIM_CST,
+ callback: callback.bind(this)
+ });
+ },
+
+ readSPN: function() {
+ function callback() {
+ let Buf = this.context.Buf;
+ let strLen = Buf.readInt32();
+ let octetLen = strLen / 2;
+
+ let GsmPDUHelper = this.context.GsmPDUHelper;
+ let displayCondition = GsmPDUHelper.readHexOctet();
+ let codingScheme = GsmPDUHelper.readHexOctet();
+ // Skip one octet: language indicator.
+ Buf.seekIncoming(Buf.PDU_HEX_OCTET_SIZE);
+ let readLen = 3;
+
+ // SPN String ends up with 0xff.
+ let userDataBuffer = [];
+
+ while (readLen < octetLen) {
+ let octet = GsmPDUHelper.readHexOctet();
+ readLen++;
+ if (octet == 0xff) {
+ break;
+ }
+ userDataBuffer.push(octet);
+ }
+
+ this.context.BitBufferHelper.startRead(userDataBuffer);
+
+ let CdmaPDUHelper = this.context.CdmaPDUHelper;
+ let msgLen;
+ switch (CdmaPDUHelper.getCdmaMsgEncoding(codingScheme)) {
+ case PDU_DCS_MSG_CODING_7BITS_ALPHABET:
+ msgLen = Math.floor(userDataBuffer.length * 8 / 7);
+ break;
+ case PDU_DCS_MSG_CODING_8BITS_ALPHABET:
+ msgLen = userDataBuffer.length;
+ break;
+ case PDU_DCS_MSG_CODING_16BITS_ALPHABET:
+ msgLen = Math.floor(userDataBuffer.length / 2);
+ break;
+ }
+
+ let RIL = this.context.RIL;
+ RIL.iccInfo.spn = CdmaPDUHelper.decodeCdmaPDUMsg(codingScheme, null, msgLen);
+ if (DEBUG) {
+ this.context.debug("CDMA SPN: " + RIL.iccInfo.spn +
+ ", Display condition: " + displayCondition);
+ }
+ RIL.iccInfoPrivate.spnDisplayCondition = displayCondition;
+ Buf.seekIncoming((octetLen - readLen) * Buf.PDU_HEX_OCTET_SIZE);
+ Buf.readStringDelimiter(strLen);
+ }
+
+ this.context.ICCIOHelper.loadTransparentEF({
+ fileId: ICC_EF_CSIM_SPN,
+ callback: callback.bind(this)
+ });
+ }
+};
+
+/**
+ * Helper functions for ICC utilities.
+ */
+function ICCUtilsHelperObject(aContext) {
+ this.context = aContext;
+}
+ICCUtilsHelperObject.prototype = {
+ context: null,
+
+ /**
+ * Get network names by using EF_OPL and EF_PNN
+ *
+ * @See 3GPP TS 31.102 sec. 4.2.58 and sec. 4.2.59 for USIM,
+ * 3GPP TS 51.011 sec. 10.3.41 and sec. 10.3.42 for SIM.
+ *
+ * @param mcc The mobile country code of the network.
+ * @param mnc The mobile network code of the network.
+ * @param lac The location area code of the network.
+ */
+ getNetworkNameFromICC: function(mcc, mnc, lac) {
+ let RIL = this.context.RIL;
+ let iccInfoPriv = RIL.iccInfoPrivate;
+ let iccInfo = RIL.iccInfo;
+ let pnnEntry;
+
+ if (!mcc || !mnc || lac == null || lac < 0) {
+ return null;
+ }
+
+ // We won't get network name if there is no PNN file.
+ if (!iccInfoPriv.PNN) {
+ return null;
+ }
+
+ if (!this.isICCServiceAvailable("OPL")) {
+ // When OPL is not present:
+ // According to 3GPP TS 31.102 Sec. 4.2.58 and 3GPP TS 51.011 Sec. 10.3.41,
+ // If EF_OPL is not present, the first record in this EF is used for the
+ // default network name when registered to the HPLMN.
+ // If we haven't get pnnEntry assigned, we should try to assign default
+ // value to it.
+ if (mcc == iccInfo.mcc && mnc == iccInfo.mnc) {
+ pnnEntry = iccInfoPriv.PNN[0];
+ }
+ } else {
+ let GsmPDUHelper = this.context.GsmPDUHelper;
+ let wildChar = GsmPDUHelper.extendedBcdChars.charAt(0x0d);
+ // According to 3GPP TS 31.102 Sec. 4.2.59 and 3GPP TS 51.011 Sec. 10.3.42,
+ // the ME shall use this EF_OPL in association with the EF_PNN in place
+ // of any network name stored within the ME's internal list and any network
+ // name received when registered to the PLMN.
+ let length = iccInfoPriv.OPL ? iccInfoPriv.OPL.length : 0;
+ for (let i = 0; i < length; i++) {
+ let unmatch = false;
+ let opl = iccInfoPriv.OPL[i];
+ // Try to match the MCC/MNC. Besides, A BCD value of 'D' in any of the
+ // MCC and/or MNC digits shall be used to indicate a "wild" value for
+ // that corresponding MCC/MNC digit.
+ if (opl.mcc.indexOf(wildChar) !== -1) {
+ for (let j = 0; j < opl.mcc.length; j++) {
+ if (opl.mcc[j] !== wildChar && opl.mcc[j] !== mcc[j]) {
+ unmatch = true;
+ break;
+ }
+ }
+ if (unmatch) {
+ continue;
+ }
+ } else {
+ if (mcc !== opl.mcc) {
+ continue;
+ }
+ }
+
+ if (mnc.length !== opl.mnc.length) {
+ continue;
+ }
+
+ if (opl.mnc.indexOf(wildChar) !== -1) {
+ for (let j = 0; j < opl.mnc.length; j++) {
+ if (opl.mnc[j] !== wildChar && opl.mnc[j] !== mnc[j]) {
+ unmatch = true;
+ break;
+ }
+ }
+ if (unmatch) {
+ continue;
+ }
+ } else {
+ if (mnc !== opl.mnc) {
+ continue;
+ }
+ }
+
+ // Try to match the location area code. If current local area code is
+ // covered by lac range that specified in the OPL entry, use the PNN
+ // that specified in the OPL entry.
+ if ((opl.lacTacStart === 0x0 && opl.lacTacEnd == 0xFFFE) ||
+ (opl.lacTacStart <= lac && opl.lacTacEnd >= lac)) {
+ if (opl.pnnRecordId === 0) {
+ // See 3GPP TS 31.102 Sec. 4.2.59 and 3GPP TS 51.011 Sec. 10.3.42,
+ // A value of '00' indicates that the name is to be taken from other
+ // sources.
+ return null;
+ }
+ pnnEntry = iccInfoPriv.PNN[opl.pnnRecordId - 1];
+ break;
+ }
+ }
+ }
+
+ if (!pnnEntry) {
+ return null;
+ }
+
+ // Return a new object to avoid global variable, PNN, be modified by accident.
+ return { fullName: pnnEntry.fullName || "",
+ shortName: pnnEntry.shortName || "" };
+ },
+
+ /**
+ * This will compute the spnDisplay field of the network.
+ * See TS 22.101 Annex A and TS 51.011 10.3.11 for details.
+ *
+ * @return True if some of iccInfo is changed in by this function.
+ */
+ updateDisplayCondition: function() {
+ let RIL = this.context.RIL;
+
+ // If EFspn isn't existed in SIM or it haven't been read yet, we should
+ // just set isDisplayNetworkNameRequired = true and
+ // isDisplaySpnRequired = false
+ let iccInfo = RIL.iccInfo;
+ let iccInfoPriv = RIL.iccInfoPrivate;
+ let displayCondition = iccInfoPriv.spnDisplayCondition;
+ let origIsDisplayNetworkNameRequired = iccInfo.isDisplayNetworkNameRequired;
+ let origIsDisplaySPNRequired = iccInfo.isDisplaySpnRequired;
+
+ if (displayCondition === undefined) {
+ iccInfo.isDisplayNetworkNameRequired = true;
+ iccInfo.isDisplaySpnRequired = false;
+ } else if (RIL._isCdma) {
+ // CDMA family display rule.
+ let cdmaHome = RIL.cdmaHome;
+ let cell = RIL.voiceRegistrationState.cell;
+ let sid = cell && cell.cdmaSystemId;
+ let nid = cell && cell.cdmaNetworkId;
+
+ iccInfo.isDisplayNetworkNameRequired = false;
+
+ // If display condition is 0x0, we don't even need to check network id
+ // or system id.
+ if (displayCondition === 0x0) {
+ iccInfo.isDisplaySpnRequired = false;
+ } else {
+ // CDMA SPN Display condition dosen't specify whenever network name is
+ // reqired.
+ if (!cdmaHome ||
+ !cdmaHome.systemId ||
+ cdmaHome.systemId.length === 0 ||
+ cdmaHome.systemId.length != cdmaHome.networkId.length ||
+ !sid || !nid) {
+ // CDMA Home haven't been ready, or we haven't got the system id and
+ // network id of the network we register to, assuming we are in home
+ // network.
+ iccInfo.isDisplaySpnRequired = true;
+ } else {
+ // Determine if we are registered in the home service area.
+ // System ID and Network ID are described in 3GPP2 C.S0005 Sec. 2.6.5.2.
+ let inHomeArea = false;
+ for (let i = 0; i < cdmaHome.systemId.length; i++) {
+ let homeSid = cdmaHome.systemId[i],
+ homeNid = cdmaHome.networkId[i];
+ if (homeSid === 0 || homeNid === 0 // Reserved system id/network id
+ || homeSid != sid) {
+ continue;
+ }
+ // According to 3GPP2 C.S0005 Sec. 2.6.5.2, NID number 65535 means
+ // all networks in the system should be considered as home.
+ if (homeNid == 65535 || homeNid == nid) {
+ inHomeArea = true;
+ break;
+ }
+ }
+ iccInfo.isDisplaySpnRequired = inHomeArea;
+ }
+ }
+ } else {
+ // GSM family display rule.
+ let operatorMnc = RIL.operator ? RIL.operator.mnc : -1;
+ let operatorMcc = RIL.operator ? RIL.operator.mcc : -1;
+
+ // First detect if we are on HPLMN or one of the PLMN
+ // specified by the SIM card.
+ let isOnMatchingPlmn = false;
+
+ // If the current network is the one defined as mcc/mnc
+ // in SIM card, it's okay.
+ if (iccInfo.mcc == operatorMcc && iccInfo.mnc == operatorMnc) {
+ isOnMatchingPlmn = true;
+ }
+
+ // Test to see if operator's mcc/mnc match mcc/mnc of PLMN.
+ if (!isOnMatchingPlmn && iccInfoPriv.SPDI) {
+ let iccSpdi = iccInfoPriv.SPDI; // PLMN list
+ for (let plmn in iccSpdi) {
+ let plmnMcc = iccSpdi[plmn].mcc;
+ let plmnMnc = iccSpdi[plmn].mnc;
+ isOnMatchingPlmn = (plmnMcc == operatorMcc) && (plmnMnc == operatorMnc);
+ if (isOnMatchingPlmn) {
+ break;
+ }
+ }
+ }
+
+ // See 3GPP TS 22.101 A.4 Service Provider Name indication, and TS 31.102
+ // clause 4.2.12 EF_SPN for detail.
+ if (isOnMatchingPlmn) {
+ // The first bit of display condition tells us if we should display
+ // registered PLMN.
+ if (DEBUG) {
+ this.context.debug("PLMN is HPLMN or PLMN " + "is in PLMN list");
+ }
+
+ // TS 31.102 Sec. 4.2.66 and TS 51.011 Sec. 10.3.50
+ // EF_SPDI contains a list of PLMNs in which the Service Provider Name
+ // shall be displayed.
+ iccInfo.isDisplaySpnRequired = true;
+ iccInfo.isDisplayNetworkNameRequired = (displayCondition & 0x01) !== 0;
+ } else {
+ // The second bit of display condition tells us if we should display
+ // registered PLMN.
+ if (DEBUG) {
+ this.context.debug("PLMN isn't HPLMN and PLMN isn't in PLMN list");
+ }
+
+ iccInfo.isDisplayNetworkNameRequired = true;
+ iccInfo.isDisplaySpnRequired = (displayCondition & 0x02) === 0;
+ }
+ }
+
+ if (DEBUG) {
+ this.context.debug("isDisplayNetworkNameRequired = " +
+ iccInfo.isDisplayNetworkNameRequired);
+ this.context.debug("isDisplaySpnRequired = " + iccInfo.isDisplaySpnRequired);
+ }
+
+ return ((origIsDisplayNetworkNameRequired !== iccInfo.isDisplayNetworkNameRequired) ||
+ (origIsDisplaySPNRequired !== iccInfo.isDisplaySpnRequired));
+ },
+
+ decodeSimTlvs: function(tlvsLen) {
+ let GsmPDUHelper = this.context.GsmPDUHelper;
+
+ let index = 0;
+ let tlvs = [];
+ while (index < tlvsLen) {
+ let simTlv = {
+ tag : GsmPDUHelper.readHexOctet(),
+ length : GsmPDUHelper.readHexOctet(),
+ };
+ simTlv.value = GsmPDUHelper.readHexOctetArray(simTlv.length);
+ tlvs.push(simTlv);
+ index += simTlv.length + 2; // The length of 'tag' and 'length' field.
+ }
+ return tlvs;
+ },
+
+ /**
+ * Parse those TLVs and convert it to an object.
+ */
+ parsePbrTlvs: function(pbrTlvs) {
+ let pbr = {};
+ for (let i = 0; i < pbrTlvs.length; i++) {
+ let pbrTlv = pbrTlvs[i];
+ let anrIndex = 0;
+ for (let j = 0; j < pbrTlv.value.length; j++) {
+ let tlv = pbrTlv.value[j];
+ let tagName = USIM_TAG_NAME[tlv.tag];
+
+ // ANR could have multiple files. We save it as anr0, anr1,...etc.
+ if (tlv.tag == ICC_USIM_EFANR_TAG) {
+ tagName += anrIndex;
+ anrIndex++;
+ }
+ pbr[tagName] = tlv;
+ pbr[tagName].fileType = pbrTlv.tag;
+ pbr[tagName].fileId = (tlv.value[0] << 8) | tlv.value[1];
+ pbr[tagName].sfi = tlv.value[2];
+
+ // For Type 2, the order of files is in the same order in IAP.
+ if (pbrTlv.tag == ICC_USIM_TYPE2_TAG) {
+ pbr[tagName].indexInIAP = j;
+ }
+ }
+ }
+
+ return pbr;
+ },
+
+ /**
+ * Update the ICC information to RadioInterfaceLayer.
+ */
+ handleICCInfoChange: function() {
+ let RIL = this.context.RIL;
+ RIL.iccInfo.rilMessageType = "iccinfochange";
+ RIL.sendChromeMessage(RIL.iccInfo);
+ },
+
+ /**
+ * Get whether specificed (U)SIM service is available.
+ *
+ * @param geckoService
+ * Service name like "ADN", "BDN", etc.
+ *
+ * @return true if the service is enabled, false otherwise.
+ */
+ isICCServiceAvailable: function(geckoService) {
+ let RIL = this.context.RIL;
+ let serviceTable = RIL._isCdma ? RIL.iccInfoPrivate.cst:
+ RIL.iccInfoPrivate.sst;
+ let index, bitmask;
+ if (RIL.appType == CARD_APPTYPE_SIM || RIL.appType == CARD_APPTYPE_RUIM) {
+ /**
+ * Service id is valid in 1..N, and 2 bits are used to code each service.
+ *
+ * +----+-- --+----+----+
+ * | b8 | ... | b2 | b1 |
+ * +----+-- --+----+----+
+ *
+ * b1 = 0, service not allocated.
+ * 1, service allocated.
+ * b2 = 0, service not activated.
+ * 1, service activated.
+ *
+ * @see 3GPP TS 51.011 10.3.7.
+ */
+ let simService;
+ if (RIL.appType == CARD_APPTYPE_SIM) {
+ simService = GECKO_ICC_SERVICES.sim[geckoService];
+ } else {
+ simService = GECKO_ICC_SERVICES.ruim[geckoService];
+ }
+ if (!simService) {
+ return false;
+ }
+ simService -= 1;
+ index = Math.floor(simService / 4);
+ bitmask = 2 << ((simService % 4) << 1);
+ } else if (RIL.appType == CARD_APPTYPE_USIM) {
+ /**
+ * Service id is valid in 1..N, and 1 bit is used to code each service.
+ *
+ * +----+-- --+----+----+
+ * | b8 | ... | b2 | b1 |
+ * +----+-- --+----+----+
+ *
+ * b1 = 0, service not avaiable.
+ * 1, service available.
+ *
+ * @see 3GPP TS 31.102 4.2.8.
+ */
+ let usimService = GECKO_ICC_SERVICES.usim[geckoService];
+ if (!usimService) {
+ return false;
+ }
+ usimService -= 1;
+ index = Math.floor(usimService / 8);
+ bitmask = 1 << ((usimService % 8) << 0);
+ }
+
+ return (serviceTable !== null) &&
+ (index < serviceTable.length) &&
+ ((serviceTable[index] & bitmask) !== 0);
+ },
+
+ /**
+ * Get whether specificed CPHS service is available.
+ *
+ * @param geckoService
+ * Service name like "MDN", etc.
+ *
+ * @return true if the service is enabled, false otherwise.
+ */
+ isCphsServiceAvailable: function(geckoService) {
+ let RIL = this.context.RIL;
+ let serviceTable = RIL.iccInfoPrivate.cphsSt;
+
+ if (!(serviceTable instanceof Uint8Array)) {
+ return false;
+ }
+
+ /**
+ * Service id is valid in 1..N, and 2 bits are used to code each service.
+ *
+ * +----+-- --+----+----+
+ * | b8 | ... | b2 | b1 |
+ * +----+-- --+----+----+
+ *
+ * b1 = 0, service not allocated.
+ * 1, service allocated.
+ * b2 = 0, service not activated.
+ * 1, service activated.
+ *
+ * @See B.3.1.1 CPHS Information in CPHS Phase 2.
+ */
+ let cphsService = GECKO_ICC_SERVICES.cphs[geckoService];
+
+ if (!cphsService) {
+ return false;
+ }
+ cphsService -= 1;
+ let index = Math.floor(cphsService / 4);
+ let bitmask = 2 << ((cphsService % 4) << 1);
+
+ return (index < serviceTable.length) &&
+ ((serviceTable[index] & bitmask) !== 0);
+ },
+
+ /**
+ * Check if the string is of GSM default 7-bit coded alphabets with bit 8
+ * set to 0.
+ *
+ * @param str String to be checked.
+ */
+ isGsm8BitAlphabet: function(str) {
+ if (!str) {
+ return false;
+ }
+
+ const langTable = PDU_NL_LOCKING_SHIFT_TABLES[PDU_NL_IDENTIFIER_DEFAULT];
+ const langShiftTable = PDU_NL_SINGLE_SHIFT_TABLES[PDU_NL_IDENTIFIER_DEFAULT];
+
+ for (let i = 0; i < str.length; i++) {
+ let c = str.charAt(i);
+ let octet = langTable.indexOf(c);
+ if (octet == -1) {
+ octet = langShiftTable.indexOf(c);
+ if (octet == -1) {
+ return false;
+ }
+ }
+ }
+
+ return true;
+ },
+
+ /**
+ * Parse MCC/MNC from IMSI. If there is no available value for the length of
+ * mnc, it will use the data in MCC table to parse.
+ *
+ * @param imsi
+ * The imsi of icc.
+ * @param mncLength [optional]
+ * The length of mnc.
+ * Zero indicates we haven't got a valid mnc length.
+ *
+ * @return An object contains the parsing result of mcc and mnc.
+ * Or null if any error occurred.
+ */
+ parseMccMncFromImsi: function(imsi, mncLength) {
+ if (!imsi) {
+ return null;
+ }
+
+ // MCC is the first 3 digits of IMSI.
+ let mcc = imsi.substr(0,3);
+ if (!mncLength) {
+ // Check the MCC/MNC table for MNC length = 3 first for the case we don't
+ // have the 4th byte data from EF_AD.
+ if (PLMN_HAVING_3DIGITS_MNC[mcc] &&
+ PLMN_HAVING_3DIGITS_MNC[mcc].indexOf(imsi.substr(3, 3)) !== -1) {
+ mncLength = 3;
+ } else {
+ // Check the MCC table to decide the length of MNC.
+ let index = MCC_TABLE_FOR_MNC_LENGTH_IS_3.indexOf(mcc);
+ mncLength = (index !== -1) ? 3 : 2;
+ }
+ }
+ let mnc = imsi.substr(3, mncLength);
+ if (DEBUG) {
+ this.context.debug("IMSI: " + imsi + " MCC: " + mcc + " MNC: " + mnc);
+ }
+
+ return { mcc: mcc, mnc: mnc};
+ },
+};
+
+/**
+ * Helper for ICC Contacts.
+ */
+function ICCContactHelperObject(aContext) {
+ this.context = aContext;
+}
+ICCContactHelperObject.prototype = {
+ context: null,
+
+ /**
+ * Helper function to check DF_PHONEBOOK.
+ */
+ hasDfPhoneBook: function(appType) {
+ switch (appType) {
+ case CARD_APPTYPE_SIM:
+ return false;
+ case CARD_APPTYPE_USIM:
+ return true;
+ case CARD_APPTYPE_RUIM:
+ let ICCUtilsHelper = this.context.ICCUtilsHelper;
+ return ICCUtilsHelper.isICCServiceAvailable("ENHANCED_PHONEBOOK");
+ default:
+ return false;
+ }
+ },
+
+ /**
+ * Helper function to read ICC contacts.
+ *
+ * @param appType One of CARD_APPTYPE_*.
+ * @param contactType One of GECKO_CARDCONTACT_TYPE_*.
+ * @param onsuccess Callback to be called when success.
+ * @param onerror Callback to be called when error.
+ */
+ readICCContacts: function(appType, contactType, onsuccess, onerror) {
+ let ICCRecordHelper = this.context.ICCRecordHelper;
+ let ICCUtilsHelper = this.context.ICCUtilsHelper;
+
+ switch (contactType) {
+ case GECKO_CARDCONTACT_TYPE_ADN:
+ if (!this.hasDfPhoneBook(appType)) {
+ ICCRecordHelper.readADNLike(ICC_EF_ADN,
+ (ICCUtilsHelper.isICCServiceAvailable("EXT1")) ? ICC_EF_EXT1 : null,
+ onsuccess, onerror);
+ } else {
+ this.readUSimContacts(onsuccess, onerror);
+ }
+ break;
+ case GECKO_CARDCONTACT_TYPE_FDN:
+ if (!ICCUtilsHelper.isICCServiceAvailable("FDN")) {
+ onerror(CONTACT_ERR_CONTACT_TYPE_NOT_SUPPORTED);
+ break;
+ }
+ ICCRecordHelper.readADNLike(ICC_EF_FDN,
+ (ICCUtilsHelper.isICCServiceAvailable("EXT2")) ? ICC_EF_EXT2 : null,
+ onsuccess, onerror);
+ break;
+ case GECKO_CARDCONTACT_TYPE_SDN:
+ if (!ICCUtilsHelper.isICCServiceAvailable("SDN")) {
+ onerror(CONTACT_ERR_CONTACT_TYPE_NOT_SUPPORTED);
+ break;
+ }
+
+ ICCRecordHelper.readADNLike(ICC_EF_SDN,
+ (ICCUtilsHelper.isICCServiceAvailable("EXT3")) ? ICC_EF_EXT3 : null,
+ onsuccess, onerror);
+ break;
+ default:
+ if (DEBUG) {
+ this.context.debug("Unsupported contactType :" + contactType);
+ }
+ onerror(CONTACT_ERR_CONTACT_TYPE_NOT_SUPPORTED);
+ break;
+ }
+ },
+
+ /**
+ * Helper function to find free contact record.
+ *
+ * @param appType One of CARD_APPTYPE_*.
+ * @param contactType One of GECKO_CARDCONTACT_TYPE_*.
+ * @param onsuccess Callback to be called when success.
+ * @param onerror Callback to be called when error.
+ */
+ findFreeICCContact: function(appType, contactType, onsuccess, onerror) {
+ let ICCRecordHelper = this.context.ICCRecordHelper;
+
+ switch (contactType) {
+ case GECKO_CARDCONTACT_TYPE_ADN:
+ if (!this.hasDfPhoneBook(appType)) {
+ ICCRecordHelper.findFreeRecordId(ICC_EF_ADN, onsuccess.bind(null, 0), onerror);
+ } else {
+ let gotPbrCb = function gotPbrCb(pbrs) {
+ this.findUSimFreeADNRecordId(pbrs, onsuccess, onerror);
+ }.bind(this);
+
+ ICCRecordHelper.readPBR(gotPbrCb, onerror);
+ }
+ break;
+ case GECKO_CARDCONTACT_TYPE_FDN:
+ ICCRecordHelper.findFreeRecordId(ICC_EF_FDN, onsuccess.bind(null, 0), onerror);
+ break;
+ default:
+ if (DEBUG) {
+ this.context.debug("Unsupported contactType :" + contactType);
+ }
+ onerror(CONTACT_ERR_CONTACT_TYPE_NOT_SUPPORTED);
+ break;
+ }
+ },
+
+ /**
+ * Cache the pbr index of the possible free record.
+ */
+ _freePbrIndex: 0,
+
+ /**
+ * Find free ADN record id in USIM.
+ *
+ * @param pbrs All Phonebook Reference Files read.
+ * @param onsuccess Callback to be called when success.
+ * @param onerror Callback to be called when error.
+ */
+ findUSimFreeADNRecordId: function(pbrs, onsuccess, onerror) {
+ let ICCRecordHelper = this.context.ICCRecordHelper;
+
+ function callback(pbrIndex, recordId) {
+ // Assume other free records are probably in the same phonebook set.
+ this._freePbrIndex = pbrIndex;
+ onsuccess(pbrIndex, recordId);
+ }
+
+ let nextPbrIndex = -1;
+ (function findFreeRecordId(pbrIndex) {
+ if (nextPbrIndex === this._freePbrIndex) {
+ // No free record found, reset the pbr index of free record.
+ this._freePbrIndex = 0;
+ if (DEBUG) {
+ this.context.debug(CONTACT_ERR_NO_FREE_RECORD_FOUND);
+ }
+ onerror(CONTACT_ERR_NO_FREE_RECORD_FOUND);
+ return;
+ }
+
+ let pbr = pbrs[pbrIndex];
+ nextPbrIndex = (pbrIndex + 1) % pbrs.length;
+ ICCRecordHelper.findFreeRecordId(
+ pbr.adn.fileId,
+ callback.bind(this, pbrIndex),
+ findFreeRecordId.bind(this, nextPbrIndex));
+ }).call(this, this._freePbrIndex);
+ },
+
+ /**
+ * Helper function to add a new ICC contact.
+ *
+ * @param appType One of CARD_APPTYPE_*.
+ * @param contactType One of GECKO_CARDCONTACT_TYPE_*.
+ * @param contact The contact will be added.
+ * @param pin2 PIN2 is required for FDN.
+ * @param onsuccess Callback to be called when success.
+ * @param onerror Callback to be called when error.
+ */
+ addICCContact: function(appType, contactType, contact, pin2, onsuccess, onerror) {
+ let foundFreeCb = (function foundFreeCb(pbrIndex, recordId) {
+ contact.pbrIndex = pbrIndex;
+ contact.recordId = recordId;
+ this.updateICCContact(appType, contactType, contact, pin2, onsuccess, onerror);
+ }).bind(this);
+
+ // Find free record first.
+ this.findFreeICCContact(appType, contactType, foundFreeCb, onerror);
+ },
+
+ /**
+ * Helper function to update ICC contact.
+ *
+ * @param appType One of CARD_APPTYPE_*.
+ * @param contactType One of GECKO_CARDCONTACT_TYPE_*.
+ * @param contact The contact will be updated.
+ * @param pin2 PIN2 is required for FDN.
+ * @param onsuccess Callback to be called when success.
+ * @param onerror Callback to be called when error.
+ */
+ updateICCContact: function(appType, contactType, contact, pin2, onsuccess, onerror) {
+ let ICCRecordHelper = this.context.ICCRecordHelper;
+ let ICCUtilsHelper = this.context.ICCUtilsHelper;
+
+ let updateContactCb = (updatedContact) => {
+ updatedContact.pbrIndex = contact.pbrIndex;
+ updatedContact.recordId = contact.recordId;
+ onsuccess(updatedContact);
+ }
+
+ switch (contactType) {
+ case GECKO_CARDCONTACT_TYPE_ADN:
+ if (!this.hasDfPhoneBook(appType)) {
+ if (ICCUtilsHelper.isICCServiceAvailable("EXT1")) {
+ this.updateADNLikeWithExtension(ICC_EF_ADN, ICC_EF_EXT1,
+ contact, null,
+ updateContactCb, onerror);
+ } else {
+ ICCRecordHelper.updateADNLike(ICC_EF_ADN, 0xff,
+ contact, null,
+ updateContactCb, onerror);
+ }
+ } else {
+ this.updateUSimContact(contact, updateContactCb, onerror);
+ }
+ break;
+ case GECKO_CARDCONTACT_TYPE_FDN:
+ if (!pin2) {
+ onerror(GECKO_ERROR_SIM_PIN2);
+ return;
+ }
+ if (!ICCUtilsHelper.isICCServiceAvailable("FDN")) {
+ onerror(CONTACT_ERR_CONTACT_TYPE_NOT_SUPPORTED);
+ break;
+ }
+ if (ICCUtilsHelper.isICCServiceAvailable("EXT2")) {
+ this.updateADNLikeWithExtension(ICC_EF_FDN, ICC_EF_EXT2,
+ contact, pin2,
+ updateContactCb, onerror);
+ } else {
+ ICCRecordHelper.updateADNLike(ICC_EF_FDN,
+ 0xff,
+ contact, pin2,
+ updateContactCb, onerror);
+ }
+ break;
+ default:
+ if (DEBUG) {
+ this.context.debug("Unsupported contactType :" + contactType);
+ }
+ onerror(CONTACT_ERR_CONTACT_TYPE_NOT_SUPPORTED);
+ break;
+ }
+ },
+
+ /**
+ * Read contacts from USIM.
+ *
+ * @param onsuccess Callback to be called when success.
+ * @param onerror Callback to be called when error.
+ */
+ readUSimContacts: function(onsuccess, onerror) {
+ let gotPbrCb = function gotPbrCb(pbrs) {
+ this.readAllPhonebookSets(pbrs, onsuccess, onerror);
+ }.bind(this);
+
+ this.context.ICCRecordHelper.readPBR(gotPbrCb, onerror);
+ },
+
+ /**
+ * Read all Phonebook sets.
+ *
+ * @param pbrs All Phonebook Reference Files read.
+ * @param onsuccess Callback to be called when success.
+ * @param onerror Callback to be called when error.
+ */
+ readAllPhonebookSets: function(pbrs, onsuccess, onerror) {
+ let allContacts = [], pbrIndex = 0;
+ let readPhonebook = function(contacts) {
+ if (contacts) {
+ allContacts = allContacts.concat(contacts);
+ }
+
+ let cLen = contacts ? contacts.length : 0;
+ for (let i = 0; i < cLen; i++) {
+ contacts[i].pbrIndex = pbrIndex;
+ }
+
+ pbrIndex++;
+ if (pbrIndex >= pbrs.length) {
+ if (onsuccess) {
+ onsuccess(allContacts);
+ }
+ return;
+ }
+
+ this.readPhonebookSet(pbrs[pbrIndex], readPhonebook, onerror);
+ }.bind(this);
+
+ this.readPhonebookSet(pbrs[pbrIndex], readPhonebook, onerror);
+ },
+
+ /**
+ * Read from Phonebook Reference File.
+ *
+ * @param pbr Phonebook Reference File to be read.
+ * @param onsuccess Callback to be called when success.
+ * @param onerror Callback to be called when error.
+ */
+ readPhonebookSet: function(pbr, onsuccess, onerror) {
+ let ICCRecordHelper = this.context.ICCRecordHelper;
+ let gotAdnCb = function gotAdnCb(contacts) {
+ this.readSupportedPBRFields(pbr, contacts, onsuccess, onerror);
+ }.bind(this);
+
+ ICCRecordHelper.readADNLike(pbr.adn.fileId,
+ (pbr.ext1) ? pbr.ext1.fileId : null, gotAdnCb, onerror);
+ },
+
+ /**
+ * Read supported Phonebook fields.
+ *
+ * @param pbr Phone Book Reference file.
+ * @param contacts Contacts stored on ICC.
+ * @param onsuccess Callback to be called when success.
+ * @param onerror Callback to be called when error.
+ */
+ readSupportedPBRFields: function(pbr, contacts, onsuccess, onerror) {
+ let fieldIndex = 0;
+ (function readField() {
+ let field = USIM_PBR_FIELDS[fieldIndex];
+ fieldIndex += 1;
+ if (!field) {
+ if (onsuccess) {
+ onsuccess(contacts);
+ }
+ return;
+ }
+
+ this.readPhonebookField(pbr, contacts, field, readField.bind(this), onerror);
+ }).call(this);
+ },
+
+ /**
+ * Read Phonebook field.
+ *
+ * @param pbr The phonebook reference file.
+ * @param contacts Contacts stored on ICC.
+ * @param field Phonebook field to be retrieved.
+ * @param onsuccess Callback to be called when success.
+ * @param onerror Callback to be called when error.
+ */
+ readPhonebookField: function(pbr, contacts, field, onsuccess, onerror) {
+ if (!pbr[field]) {
+ if (onsuccess) {
+ onsuccess(contacts);
+ }
+ return;
+ }
+
+ (function doReadContactField(n) {
+ if (n >= contacts.length) {
+ // All contact's fields are read.
+ if (onsuccess) {
+ onsuccess(contacts);
+ }
+ return;
+ }
+
+ // get n-th contact's field.
+ this.readContactField(pbr, contacts[n], field,
+ doReadContactField.bind(this, n + 1), onerror);
+ }).call(this, 0);
+ },
+
+ /**
+ * Read contact's field from USIM.
+ *
+ * @param pbr The phonebook reference file.
+ * @param contact The contact needs to get field.
+ * @param field Phonebook field to be retrieved.
+ * @param onsuccess Callback to be called when success.
+ * @param onerror Callback to be called when error.
+ */
+ readContactField: function(pbr, contact, field, onsuccess, onerror) {
+ let gotRecordIdCb = function gotRecordIdCb(recordId) {
+ if (recordId == 0xff) {
+ if (onsuccess) {
+ onsuccess();
+ }
+ return;
+ }
+
+ let fileId = pbr[field].fileId;
+ let fileType = pbr[field].fileType;
+ let gotFieldCb = function gotFieldCb(value) {
+ if (value) {
+ // Move anr0 anr1,.. into anr[].
+ if (field.startsWith(USIM_PBR_ANR)) {
+ if (!contact[USIM_PBR_ANR]) {
+ contact[USIM_PBR_ANR] = [];
+ }
+ contact[USIM_PBR_ANR].push(value);
+ } else {
+ contact[field] = value;
+ }
+ }
+
+ if (onsuccess) {
+ onsuccess();
+ }
+ }.bind(this);
+
+ let ICCRecordHelper = this.context.ICCRecordHelper;
+ // Detect EF to be read, for anr, it could have anr0, anr1,...
+ let ef = field.startsWith(USIM_PBR_ANR) ? USIM_PBR_ANR : field;
+ switch (ef) {
+ case USIM_PBR_EMAIL:
+ ICCRecordHelper.readEmail(fileId, fileType, recordId, gotFieldCb, onerror);
+ break;
+ case USIM_PBR_ANR:
+ ICCRecordHelper.readANR(fileId, fileType, recordId, gotFieldCb, onerror);
+ break;
+ default:
+ if (DEBUG) {
+ this.context.debug("Unsupported field :" + field);
+ }
+ onerror(CONTACT_ERR_FIELD_NOT_SUPPORTED);
+ break;
+ }
+ }.bind(this);
+
+ this.getContactFieldRecordId(pbr, contact, field, gotRecordIdCb, onerror);
+ },
+
+ /**
+ * Get the recordId.
+ *
+ * If the fileType of field is ICC_USIM_TYPE1_TAG, use corresponding ADN recordId.
+ * otherwise get the recordId from IAP.
+ *
+ * @see TS 131.102, clause 4.4.2.2
+ *
+ * @param pbr The phonebook reference file.
+ * @param contact The contact will be updated.
+ * @param onsuccess Callback to be called when success.
+ * @param onerror Callback to be called when error.
+ */
+ getContactFieldRecordId: function(pbr, contact, field, onsuccess, onerror) {
+ if (pbr[field].fileType == ICC_USIM_TYPE1_TAG) {
+ // If the file type is ICC_USIM_TYPE1_TAG, use corresponding ADN recordId.
+ if (onsuccess) {
+ onsuccess(contact.recordId);
+ }
+ } else if (pbr[field].fileType == ICC_USIM_TYPE2_TAG) {
+ // If the file type is ICC_USIM_TYPE2_TAG, the recordId shall be got from IAP.
+ let gotIapCb = function gotIapCb(iap) {
+ let indexInIAP = pbr[field].indexInIAP;
+ let recordId = iap[indexInIAP];
+
+ if (onsuccess) {
+ onsuccess(recordId);
+ }
+ }.bind(this);
+
+ this.context.ICCRecordHelper.readIAP(pbr.iap.fileId, contact.recordId,
+ gotIapCb, onerror);
+ } else {
+ if (DEBUG) {
+ this.context.debug("USIM PBR files in Type 3 format are not supported.");
+ }
+ onerror(CONTACT_ERR_REQUEST_NOT_SUPPORTED);
+ }
+ },
+
+ /**
+ * Update USIM contact.
+ *
+ * @param contact The contact will be updated.
+ * @param onsuccess Callback to be called when success.
+ * @param onerror Callback to be called when error.
+ */
+ updateUSimContact: function(contact, onsuccess, onerror) {
+ let gotPbrCb = function gotPbrCb(pbrs) {
+ let pbr = pbrs[contact.pbrIndex];
+ if (!pbr) {
+ if (DEBUG) {
+ this.context.debug(CONTACT_ERR_CANNOT_ACCESS_PHONEBOOK);
+ }
+ onerror(CONTACT_ERR_CANNOT_ACCESS_PHONEBOOK);
+ return;
+ }
+ this.updatePhonebookSet(pbr, contact, onsuccess, onerror);
+ }.bind(this);
+
+ this.context.ICCRecordHelper.readPBR(gotPbrCb, onerror);
+ },
+
+ /**
+ * Update fields in Phonebook Reference File.
+ *
+ * @param pbr Phonebook Reference File to be read.
+ * @param onsuccess Callback to be called when success.
+ * @param onerror Callback to be called when error.
+ */
+ updatePhonebookSet: function(pbr, contact, onsuccess, onerror) {
+ let updateAdnCb = function(updatedContact) {
+ this.updateSupportedPBRFields(pbr, contact, (updatedContactField) => {
+ onsuccess(Object.assign(updatedContact, updatedContactField));
+ }, onerror);
+ }.bind(this);
+
+ if (pbr.ext1) {
+ this.updateADNLikeWithExtension(pbr.adn.fileId, pbr.ext1.fileId,
+ contact, null, updateAdnCb, onerror);
+ } else {
+ this.context.ICCRecordHelper.updateADNLike(pbr.adn.fileId, 0xff, contact,
+ null, updateAdnCb, onerror);
+ }
+ },
+
+ /**
+ * Update supported Phonebook fields.
+ *
+ * @param pbr Phone Book Reference file.
+ * @param contact Contact to be updated.
+ * @param onsuccess Callback to be called when success.
+ * @param onerror Callback to be called when error.
+ */
+ updateSupportedPBRFields: function(pbr, contact, onsuccess, onerror) {
+ let fieldIndex = 0;
+ let contactField = {};
+
+ (function updateField() {
+ let field = USIM_PBR_FIELDS[fieldIndex];
+ fieldIndex += 1;
+
+ if (!field) {
+ if (onsuccess) {
+ onsuccess(contactField);
+ }
+ return;
+ }
+
+ // Check if PBR has this field.
+ if (!pbr[field]) {
+ updateField.call(this);
+ return;
+ }
+
+ this.updateContactField(pbr, contact, field, (fieldEntry) => {
+ contactField = Object.assign(contactField, fieldEntry);
+ updateField.call(this);
+ }, (errorMsg) => {
+ // Bug 1194149, there are some sim cards without sufficient
+ // Type 2 USIM contact fields record. We allow user continue
+ // importing contacts.
+ if (errorMsg === CONTACT_ERR_NO_FREE_RECORD_FOUND) {
+ updateField.call(this);
+ return;
+ }
+ onerror(errorMsg);
+ });
+ }).call(this);
+ },
+
+ /**
+ * Update contact's field from USIM.
+ *
+ * @param pbr The phonebook reference file.
+ * @param contact The contact needs to be updated.
+ * @param field Phonebook field to be updated.
+ * @param onsuccess Callback to be called when success.
+ * @param onerror Callback to be called when error.
+ */
+ updateContactField: function(pbr, contact, field, onsuccess, onerror) {
+ if (pbr[field].fileType === ICC_USIM_TYPE1_TAG) {
+ this.updateContactFieldType1(pbr, contact, field, onsuccess, onerror);
+ } else if (pbr[field].fileType === ICC_USIM_TYPE2_TAG) {
+ this.updateContactFieldType2(pbr, contact, field, onsuccess, onerror);
+ } else {
+ if (DEBUG) {
+ this.context.debug("USIM PBR files in Type 3 format are not supported.");
+ }
+ onerror(CONTACT_ERR_REQUEST_NOT_SUPPORTED);
+ }
+ },
+
+ /**
+ * Update Type 1 USIM contact fields.
+ *
+ * @param pbr The phonebook reference file.
+ * @param contact The contact needs to be updated.
+ * @param field Phonebook field to be updated.
+ * @param onsuccess Callback to be called when success.
+ * @param onerror Callback to be called when error.
+ */
+ updateContactFieldType1: function(pbr, contact, field, onsuccess, onerror) {
+ let ICCRecordHelper = this.context.ICCRecordHelper;
+
+ if (field === USIM_PBR_EMAIL) {
+ ICCRecordHelper.updateEmail(pbr, contact.recordId, contact.email, null,
+ (updatedEmail) => {
+ onsuccess({email: updatedEmail});
+ }, onerror);
+ } else if (field === USIM_PBR_ANR0) {
+ let anr = Array.isArray(contact.anr) ? contact.anr[0] : null;
+ ICCRecordHelper.updateANR(pbr, contact.recordId, anr, null,
+ (updatedANR) => {
+ // ANR could have multiple files. If we support more than one anr,
+ // we will save it as anr0, anr1,...etc.
+ onsuccess((updatedANR) ? {anr: [updatedANR]} : null);
+ }, onerror);
+ } else {
+ if (DEBUG) {
+ this.context.debug("Unsupported field :" + field);
+ }
+ onerror(CONTACT_ERR_FIELD_NOT_SUPPORTED);
+ }
+ },
+
+ /**
+ * Update Type 2 USIM contact fields.
+ *
+ * @param pbr The phonebook reference file.
+ * @param contact The contact needs to be updated.
+ * @param field Phonebook field to be updated.
+ * @param onsuccess Callback to be called when success.
+ * @param onerror Callback to be called when error.
+ */
+ updateContactFieldType2: function(pbr, contact, field, onsuccess, onerror) {
+ let ICCRecordHelper = this.context.ICCRecordHelper;
+
+ // Case 1 : EF_IAP[adnRecordId] doesn't have a value(0xff)
+ // Find a free recordId for EF_field
+ // Update field with that free recordId.
+ // Update IAP.
+ //
+ // Case 2: EF_IAP[adnRecordId] has a value
+ // update EF_field[iap[field.indexInIAP]]
+
+ let gotIapCb = function gotIapCb(iap) {
+ let recordId = iap[pbr[field].indexInIAP];
+ if (recordId === 0xff) {
+ // If the value in IAP[index] is 0xff, which means the contact stored on
+ // the SIM doesn't have the additional attribute (email or anr).
+ // So if the contact to be updated doesn't have the attribute either,
+ // we don't have to update it.
+ if ((field === USIM_PBR_EMAIL && contact.email) ||
+ (field === USIM_PBR_ANR0 &&
+ (Array.isArray(contact.anr) && contact.anr[0]))) {
+ // Case 1.
+ this.addContactFieldType2(pbr, contact, field, onsuccess, onerror);
+ } else {
+ if (onsuccess) {
+ onsuccess();
+ }
+ }
+ return;
+ }
+
+ // Case 2.
+ if (field === USIM_PBR_EMAIL) {
+ ICCRecordHelper.updateEmail(pbr, recordId, contact.email, contact.recordId,
+ (updatedEmail) => {
+ onsuccess({email: updatedEmail});
+ }, onerror);
+ } else if (field === USIM_PBR_ANR0) {
+ let anr = Array.isArray(contact.anr) ? contact.anr[0] : null;
+ ICCRecordHelper.updateANR(pbr, recordId, anr, contact.recordId,
+ (updatedANR) => {
+ // ANR could have multiple files. If we support more than one anr,
+ // we will save it as anr0, anr1,...etc.
+ onsuccess((updatedANR) ? {anr: [updatedANR]} : null);
+ }, onerror);
+ } else {
+ if (DEBUG) {
+ this.context.debug("Unsupported field :" + field);
+ }
+ onerror(CONTACT_ERR_FIELD_NOT_SUPPORTED);
+ }
+
+ }.bind(this);
+
+ ICCRecordHelper.readIAP(pbr.iap.fileId, contact.recordId, gotIapCb, onerror);
+ },
+
+ /**
+ * Add Type 2 USIM contact fields.
+ *
+ * @param pbr The phonebook reference file.
+ * @param contact The contact needs to be updated.
+ * @param field Phonebook field to be updated.
+ * @param onsuccess Callback to be called when success.
+ * @param onerror Callback to be called when error.
+ */
+ addContactFieldType2: function(pbr, contact, field, onsuccess, onerror) {
+ let ICCRecordHelper = this.context.ICCRecordHelper;
+ let successCb = function successCb(recordId) {
+
+ let updateCb = function updateCb(contactField) {
+ this.updateContactFieldIndexInIAP(pbr, contact.recordId, field, recordId, () => {
+ onsuccess(contactField);
+ }, onerror);
+ }.bind(this);
+
+ if (field === USIM_PBR_EMAIL) {
+ ICCRecordHelper.updateEmail(pbr, recordId, contact.email, contact.recordId,
+ (updatedEmail) => {
+ updateCb({email: updatedEmail});
+ }, onerror);
+ } else if (field === USIM_PBR_ANR0) {
+ ICCRecordHelper.updateANR(pbr, recordId, contact.anr[0], contact.recordId,
+ (updatedANR) => {
+ // ANR could have multiple files. If we support more than one anr,
+ // we will save it as anr0, anr1,...etc.
+ updateCb((updatedANR) ? {anr: [updatedANR]} : null);
+ }, onerror);
+ }
+ }.bind(this);
+
+ let errorCb = function errorCb(errorMsg) {
+ if (DEBUG) {
+ this.context.debug(errorMsg + " USIM field " + field);
+ }
+ onerror(errorMsg);
+ }.bind(this);
+
+ ICCRecordHelper.findFreeRecordId(pbr[field].fileId, successCb, errorCb);
+ },
+
+ /**
+ * Update IAP value.
+ *
+ * @param pbr The phonebook reference file.
+ * @param recordNumber The record identifier of EF_IAP.
+ * @param field Phonebook field.
+ * @param value The value of 'field' in IAP.
+ * @param onsuccess Callback to be called when success.
+ * @param onerror Callback to be called when error.
+ *
+ */
+ updateContactFieldIndexInIAP: function(pbr, recordNumber, field, value, onsuccess, onerror) {
+ let ICCRecordHelper = this.context.ICCRecordHelper;
+
+ let gotIAPCb = function gotIAPCb(iap) {
+ iap[pbr[field].indexInIAP] = value;
+ ICCRecordHelper.updateIAP(pbr.iap.fileId, recordNumber, iap, onsuccess, onerror);
+ }.bind(this);
+ ICCRecordHelper.readIAP(pbr.iap.fileId, recordNumber, gotIAPCb, onerror);
+ },
+
+ /**
+ * Update ICC ADN like EFs with Extension, like EF_ADN, EF_FDN.
+ *
+ * @param fileId EF id of the ADN or FDN.
+ * @param extFileId EF id of the EXT.
+ * @param contact The contact will be updated. (Shall have recordId property)
+ * @param pin2 PIN2 is required when updating ICC_EF_FDN.
+ * @param onsuccess Callback to be called when success.
+ * @param onerror Callback to be called when error.
+ */
+ updateADNLikeWithExtension: function(fileId, extFileId, contact, pin2, onsuccess, onerror) {
+ let ICCRecordHelper = this.context.ICCRecordHelper;
+ let extNumber;
+
+ if (contact.number) {
+ let numStart = contact.number[0] == "+" ? 1 : 0;
+ let number = contact.number.substring(0, numStart) +
+ this.context.GsmPDUHelper.stringToExtendedBcd(
+ contact.number.substring(numStart));
+ extNumber = number.substr(numStart + ADN_MAX_NUMBER_DIGITS,
+ EXT_MAX_NUMBER_DIGITS);
+ }
+
+ ICCRecordHelper.getADNLikeExtensionRecordNumber(fileId, contact.recordId,
+ (extRecordNumber) => {
+ let updateADNLike = (extRecordNumber) => {
+ ICCRecordHelper.updateADNLike(fileId, extRecordNumber, contact,
+ pin2, (updatedContact) => {
+ if (extNumber && extRecordNumber != 0xff) {
+ updatedContact.number = updatedContact.number.concat(extNumber);
+ }
+ onsuccess(updatedContact);
+ }, onerror);
+ };
+
+ let updateExtension = (extRecordNumber) => {
+ ICCRecordHelper.updateExtension(extFileId, extRecordNumber, extNumber,
+ () => updateADNLike(extRecordNumber),
+ () => updateADNLike(0xff));
+ };
+
+ if (extNumber) {
+ if (extRecordNumber != 0xff) {
+ updateExtension(extRecordNumber);
+ return;
+ }
+
+ ICCRecordHelper.findFreeRecordId(extFileId,
+ (extRecordNumber) => updateExtension(extRecordNumber),
+ (errorMsg) => {
+ if (DEBUG) {
+ this.context.debug("Couldn't find free extension record Id for " + extFileId + ": " + errorMsg);
+ }
+ updateADNLike(0xff);
+ });
+ return;
+ }
+
+ if (extRecordNumber != 0xff) {
+ ICCRecordHelper.cleanEFRecord(extFileId, extRecordNumber,
+ () => updateADNLike(0xff), onerror);
+ return;
+ }
+
+ updateADNLike(0xff);
+ }, onerror);
+ },
+};
+
+function IconLoaderObject(aContext) {
+ this.context = aContext;
+}
+IconLoaderObject.prototype = {
+ context: null,
+
+ /**
+ * Load icons.
+ *
+ * @param recordNumbers Array of the record identifiers of EF_IMG.
+ * @param onsuccess Callback to be called when success.
+ * @param onerror Callback to be called when error.
+ */
+ loadIcons: function(recordNumbers, onsuccess, onerror) {
+ if (!recordNumbers || !recordNumbers.length) {
+ if (onerror) {
+ onerror();
+ }
+ return;
+ }
+
+ this._start({
+ recordNumbers: recordNumbers,
+ onsuccess: onsuccess,
+ onerror: onerror});
+ },
+
+ _start: function(options) {
+ let callback = (function(icons) {
+ if (!options.icons) {
+ options.icons = [];
+ }
+ for (let i = 0; i < icons.length; i++) {
+ icons[i] = this._parseRawData(icons[i]);
+ }
+ options.icons[options.currentRecordIndex] = icons;
+ options.currentRecordIndex++;
+
+ let recordNumbers = options.recordNumbers;
+ if (options.currentRecordIndex < recordNumbers.length) {
+ let recordNumber = recordNumbers[options.currentRecordIndex];
+ this.context.SimRecordHelper.readIMG(recordNumber,
+ callback,
+ options.onerror);
+ } else {
+ if (options.onsuccess) {
+ options.onsuccess(options.icons);
+ }
+ }
+ }).bind(this);
+
+ options.currentRecordIndex = 0;
+ this.context.SimRecordHelper.readIMG(options.recordNumbers[0],
+ callback,
+ options.onerror);
+ },
+
+ _parseRawData: function(rawData) {
+ let codingScheme = rawData.codingScheme;
+
+ switch (codingScheme) {
+ case ICC_IMG_CODING_SCHEME_BASIC:
+ return this._decodeBasicImage(rawData.width, rawData.height, rawData.body);
+
+ case ICC_IMG_CODING_SCHEME_COLOR:
+ case ICC_IMG_CODING_SCHEME_COLOR_TRANSPARENCY:
+ return this._decodeColorImage(codingScheme,
+ rawData.width, rawData.height,
+ rawData.bitsPerImgPoint,
+ rawData.numOfClutEntries,
+ rawData.clut, rawData.body);
+ }
+
+ return null;
+ },
+
+ _decodeBasicImage: function(width, height, body) {
+ let numOfPixels = width * height;
+ let pixelIndex = 0;
+ let currentByteIndex = 0;
+ let currentByte = 0x00;
+
+ const BLACK = 0x000000FF;
+ const WHITE = 0xFFFFFFFF;
+
+ let pixels = [];
+ while (pixelIndex < numOfPixels) {
+ // Reassign data and index for every byte (8 bits).
+ if (pixelIndex % 8 == 0) {
+ currentByte = body[currentByteIndex++];
+ }
+ let bit = (currentByte >> (7 - (pixelIndex % 8))) & 0x01;
+ pixels[pixelIndex++] = bit ? WHITE : BLACK;
+ }
+
+ return {pixels: pixels,
+ codingScheme: GECKO_IMG_CODING_SCHEME_BASIC,
+ width: width,
+ height: height};
+ },
+
+ _decodeColorImage: function(codingScheme, width, height, bitsPerImgPoint,
+ numOfClutEntries, clut, body) {
+ let mask = 0xff >> (8 - bitsPerImgPoint);
+ let bitsStartOffset = 8 - bitsPerImgPoint;
+ let bitIndex = bitsStartOffset;
+ let numOfPixels = width * height;
+ let pixelIndex = 0;
+ let currentByteIndex = 0;
+ let currentByte = body[currentByteIndex++];
+
+ let pixels = [];
+ while (pixelIndex < numOfPixels) {
+ // Reassign data and index for every byte (8 bits).
+ if (bitIndex < 0) {
+ currentByte = body[currentByteIndex++];
+ bitIndex = bitsStartOffset;
+ }
+ let clutEntry = ((currentByte >> bitIndex) & mask);
+ let clutIndex = clutEntry * ICC_CLUT_ENTRY_SIZE;
+ let alpha = codingScheme == ICC_IMG_CODING_SCHEME_COLOR_TRANSPARENCY &&
+ clutEntry == numOfClutEntries - 1;
+ pixels[pixelIndex++] = alpha ? 0x00
+ : (clut[clutIndex] << 24 |
+ clut[clutIndex + 1] << 16 |
+ clut[clutIndex + 2] << 8 |
+ 0xFF) >>> 0;
+ bitIndex -= bitsPerImgPoint;
+ }
+
+ return {pixels: pixels,
+ codingScheme: ICC_IMG_CODING_SCHEME_TO_GECKO[codingScheme],
+ width: width,
+ height: height};
+ },
+};
+
+/**
+ * Global stuff.
+ */
+
+function Context(aClientId) {
+ this.clientId = aClientId;
+
+ this.Buf = new BufObject(this);
+ this.RIL = new RilObject(this);
+ this.RIL.initRILState();
+}
+Context.prototype = {
+ clientId: null,
+ Buf: null,
+ RIL: null,
+
+ debug: function(aMessage) {
+ GLOBAL.debug("[" + this.clientId + "] " + aMessage);
+ }
+};
+
+(function() {
+ let lazySymbols = [
+ "BerTlvHelper", "BitBufferHelper", "CdmaPDUHelper",
+ "ComprehensionTlvHelper", "GsmPDUHelper", "ICCContactHelper",
+ "ICCFileHelper", "ICCIOHelper", "ICCPDUHelper", "ICCRecordHelper",
+ "ICCUtilsHelper", "RuimRecordHelper", "SimRecordHelper",
+ "StkCommandParamsFactory", "StkProactiveCmdHelper", "IconLoader",
+ ];
+
+ for (let i = 0; i < lazySymbols.length; i++) {
+ let symbol = lazySymbols[i];
+ Object.defineProperty(Context.prototype, symbol, {
+ get: function() {
+ let real = new GLOBAL[symbol + "Object"](this);
+ Object.defineProperty(this, symbol, {
+ value: real,
+ enumerable: true
+ });
+ return real;
+ },
+ configurable: true,
+ enumerable: true
+ });
+ }
+})();
+
+var ContextPool = {
+ _contexts: [],
+
+ handleRilMessage: function(aClientId, aUint8Array) {
+ let context = this._contexts[aClientId];
+ context.Buf.processIncoming(aUint8Array);
+ },
+
+ handleChromeMessage: function(aMessage) {
+ let clientId = aMessage.rilMessageClientId;
+ if (clientId != null) {
+ let context = this._contexts[clientId];
+ context.RIL.handleChromeMessage(aMessage);
+ return;
+ }
+
+ if (DEBUG) debug("Received global chrome message " + JSON.stringify(aMessage));
+ let method = this[aMessage.rilMessageType];
+ if (typeof method != "function") {
+ if (DEBUG) {
+ debug("Don't know what to do");
+ }
+ return;
+ }
+ method.call(this, aMessage);
+ },
+
+ setInitialOptions: function(aOptions) {
+ DEBUG = DEBUG_WORKER || aOptions.debug;
+
+ let quirks = aOptions.quirks;
+ RILQUIRKS_CALLSTATE_EXTRA_UINT32 = quirks.callstateExtraUint32;
+ RILQUIRKS_REQUEST_USE_DIAL_EMERGENCY_CALL = quirks.requestUseDialEmergencyCall;
+ RILQUIRKS_SIM_APP_STATE_EXTRA_FIELDS = quirks.simAppStateExtraFields;
+ RILQUIRKS_EXTRA_UINT32_2ND_CALL = quirks.extraUint2ndCall;
+ RILQUIRKS_HAVE_QUERY_ICC_LOCK_RETRY_COUNT = quirks.haveQueryIccLockRetryCount;
+ RILQUIRKS_SEND_STK_PROFILE_DOWNLOAD = quirks.sendStkProfileDownload;
+ RILQUIRKS_DATA_REGISTRATION_ON_DEMAND = quirks.dataRegistrationOnDemand;
+ RILQUIRKS_SUBSCRIPTION_CONTROL = quirks.subscriptionControl;
+ RILQUIRKS_SIGNAL_EXTRA_INT32 = quirks.signalExtraInt;
+ RILQUIRKS_AVAILABLE_NETWORKS_EXTRA_STRING = quirks.availableNetworkExtraStr;
+ RILQUIRKS_SMSC_ADDRESS_FORMAT = quirks.smscAddressFormat;
+ },
+
+ setDebugFlag: function(aOptions) {
+ DEBUG = DEBUG_WORKER || aOptions.debug;
+ },
+
+ registerClient: function(aOptions) {
+ let clientId = aOptions.clientId;
+ this._contexts[clientId] = new Context(clientId);
+ },
+};
+
+function onRILMessage(aClientId, aUint8Array) {
+ ContextPool.handleRilMessage(aClientId, aUint8Array);
+}
+
+onmessage = function onmessage(event) {
+ ContextPool.handleChromeMessage(event.data);
+};
+
+onerror = function onerror(event) {
+ if (DEBUG) debug("onerror" + event.message + "\n");
+};
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-19 16:42:51 +0000