Add m-esr52 at 52.6.0

1 files changed, 1324 insertions, 0 deletions

diff --git a/dom/system/gonk/RadioInterfaceLayer.js b/dom/system/gonk/RadioInterfaceLayer.js
new file mode 100644
index 000000000..f5885db5d
--- /dev/null
+++ b/dom/system/gonk/RadioInterfaceLayer.js
@@ -0,0 +1,1324 @@
+/* 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.
+ */
+
+"use strict";
+
+const {classes: Cc, interfaces: Ci, utils: Cu, results: Cr} = Components;
+
+Cu.import("resource://gre/modules/XPCOMUtils.jsm");
+Cu.import("resource://gre/modules/Services.jsm");
+Cu.import("resource://gre/modules/Sntp.jsm");
+Cu.import("resource://gre/modules/systemlibs.js");
+Cu.import("resource://gre/modules/Promise.jsm");
+Cu.import("resource://gre/modules/FileUtils.jsm");
+
+XPCOMUtils.defineLazyGetter(this, "RIL", function () {
+  let obj = {};
+  Cu.import("resource://gre/modules/ril_consts.js", obj);
+  return obj;
+});
+
+// Ril quirk to always turn the radio off for the client without SIM card
+// except hw default client.
+var RILQUIRKS_RADIO_OFF_WO_CARD =
+  libcutils.property_get("ro.moz.ril.radio_off_wo_card", "false") == "true";
+
+const RADIOINTERFACELAYER_CID =
+  Components.ID("{2d831c8d-6017-435b-a80c-e5d422810cea}");
+const RADIOINTERFACE_CID =
+  Components.ID("{6a7c91f0-a2b3-4193-8562-8969296c0b54}");
+
+const NS_XPCOM_SHUTDOWN_OBSERVER_ID      = "xpcom-shutdown";
+const kNetworkConnStateChangedTopic      = "network-connection-state-changed";
+const kMozSettingsChangedObserverTopic   = "mozsettings-changed";
+const kSysMsgListenerReadyObserverTopic  = "system-message-listener-ready";
+const kSysClockChangeObserverTopic       = "system-clock-change";
+const kScreenStateChangedTopic           = "screen-state-changed";
+
+const kSettingsClockAutoUpdateEnabled = "time.clock.automatic-update.enabled";
+const kSettingsClockAutoUpdateAvailable = "time.clock.automatic-update.available";
+const kSettingsTimezoneAutoUpdateEnabled = "time.timezone.automatic-update.enabled";
+const kSettingsTimezoneAutoUpdateAvailable = "time.timezone.automatic-update.available";
+
+const NS_PREFBRANCH_PREFCHANGE_TOPIC_ID = "nsPref:changed";
+
+const kPrefRilNumRadioInterfaces = "ril.numRadioInterfaces";
+const kPrefRilDebuggingEnabled = "ril.debugging.enabled";
+
+const RADIO_POWER_OFF_TIMEOUT = 30000;
+const HW_DEFAULT_CLIENT_ID = 0;
+
+const NETWORK_TYPE_WIFI        = Ci.nsINetworkInfo.NETWORK_TYPE_WIFI;
+const NETWORK_TYPE_MOBILE      = Ci.nsINetworkInfo.NETWORK_TYPE_MOBILE;
+
+// set to true in ril_consts.js to see debug messages
+var DEBUG = RIL.DEBUG_RIL;
+
+function updateDebugFlag() {
+  // Read debug setting from pref
+  let debugPref;
+  try {
+    debugPref = Services.prefs.getBoolPref(kPrefRilDebuggingEnabled);
+  } catch (e) {
+    debugPref = false;
+  }
+  DEBUG = RIL.DEBUG_RIL || debugPref;
+}
+updateDebugFlag();
+
+function debug(s) {
+  dump("-*- RadioInterfaceLayer: " + s + "\n");
+}
+
+XPCOMUtils.defineLazyServiceGetter(this, "gIccService",
+                                   "@mozilla.org/icc/gonkiccservice;1",
+                                   "nsIGonkIccService");
+
+XPCOMUtils.defineLazyServiceGetter(this, "gMobileMessageService",
+                                   "@mozilla.org/mobilemessage/mobilemessageservice;1",
+                                   "nsIMobileMessageService");
+
+XPCOMUtils.defineLazyServiceGetter(this, "gSmsService",
+                                   "@mozilla.org/sms/gonksmsservice;1",
+                                   "nsIGonkSmsService");
+
+XPCOMUtils.defineLazyServiceGetter(this, "ppmm",
+                                   "@mozilla.org/parentprocessmessagemanager;1",
+                                   "nsIMessageBroadcaster");
+
+XPCOMUtils.defineLazyServiceGetter(this, "gSettingsService",
+                                   "@mozilla.org/settingsService;1",
+                                   "nsISettingsService");
+
+XPCOMUtils.defineLazyServiceGetter(this, "gNetworkManager",
+                                   "@mozilla.org/network/manager;1",
+                                   "nsINetworkManager");
+
+XPCOMUtils.defineLazyServiceGetter(this, "gTimeService",
+                                   "@mozilla.org/time/timeservice;1",
+                                   "nsITimeService");
+
+XPCOMUtils.defineLazyServiceGetter(this, "gSystemWorkerManager",
+                                   "@mozilla.org/telephony/system-worker-manager;1",
+                                   "nsISystemWorkerManager");
+
+XPCOMUtils.defineLazyServiceGetter(this, "gTelephonyService",
+                                   "@mozilla.org/telephony/telephonyservice;1",
+                                   "nsIGonkTelephonyService");
+
+XPCOMUtils.defineLazyServiceGetter(this, "gMobileConnectionService",
+                                   "@mozilla.org/mobileconnection/mobileconnectionservice;1",
+                                   "nsIGonkMobileConnectionService");
+
+XPCOMUtils.defineLazyServiceGetter(this, "gCellBroadcastService",
+                                   "@mozilla.org/cellbroadcast/cellbroadcastservice;1",
+                                   "nsIGonkCellBroadcastService");
+
+XPCOMUtils.defineLazyServiceGetter(this, "gDataCallManager",
+                                   "@mozilla.org/datacall/manager;1",
+                                   "nsIDataCallManager");
+
+XPCOMUtils.defineLazyServiceGetter(this, "gDataCallInterfaceService",
+                                   "@mozilla.org/datacall/interfaceservice;1",
+                                   "nsIGonkDataCallInterfaceService");
+
+XPCOMUtils.defineLazyServiceGetter(this, "gStkCmdFactory",
+                                   "@mozilla.org/icc/stkcmdfactory;1",
+                                   "nsIStkCmdFactory");
+
+XPCOMUtils.defineLazyGetter(this, "gRadioEnabledController", function() {
+  let _ril = null;
+  let _pendingMessages = [];  // For queueing "setRadioEnabled" message.
+  let _isProcessingPending = false;
+  let _timer = null;
+  let _request = null;
+  let _deactivatingDeferred = {};
+  let _initializedCardState = {};
+  let _allCardStateInitialized = !RILQUIRKS_RADIO_OFF_WO_CARD;
+
+  return {
+    init: function(ril) {
+      _ril = ril;
+    },
+
+    receiveCardState: function(clientId) {
+      if (_allCardStateInitialized) {
+        return;
+      }
+
+      if (DEBUG) debug("RadioControl: receive cardState from " + clientId);
+      _initializedCardState[clientId] = true;
+      if (Object.keys(_initializedCardState).length == _ril.numRadioInterfaces) {
+        _allCardStateInitialized = true;
+        this._startProcessingPending();
+      }
+    },
+
+    setRadioEnabled: function(clientId, data, callback) {
+      if (DEBUG) debug("setRadioEnabled: " + clientId + ": " + JSON.stringify(data));
+      let message = {
+        clientId: clientId,
+        data: data,
+        callback: callback
+      };
+      _pendingMessages.push(message);
+      this._startProcessingPending();
+    },
+
+    notifyRadioStateChanged: function(clientId, radioState) {
+      gMobileConnectionService.notifyRadioStateChanged(clientId, radioState);
+    },
+
+    _startProcessingPending: function() {
+      if (!_isProcessingPending) {
+        if (DEBUG) debug("RadioControl: start dequeue");
+        _isProcessingPending = true;
+        this._processNextMessage();
+      }
+    },
+
+    _processNextMessage: function() {
+      if (_pendingMessages.length === 0 || !_allCardStateInitialized) {
+        if (DEBUG) debug("RadioControl: stop dequeue");
+        _isProcessingPending = false;
+        return;
+      }
+
+      let msg = _pendingMessages.shift();
+      this._handleMessage(msg);
+    },
+
+    _getNumCards: function() {
+      let numCards = 0;
+      for (let i = 0, N = _ril.numRadioInterfaces; i < N; ++i) {
+        if (_ril.getRadioInterface(i).isCardPresent()) {
+          numCards++;
+        }
+      }
+      return numCards;
+    },
+
+    _isRadioAbleToEnableAtClient: function(clientId, numCards) {
+      if (!RILQUIRKS_RADIO_OFF_WO_CARD) {
+        return true;
+      }
+
+      // We could only turn on the radio for clientId if
+      // 1. a SIM card is presented or
+      // 2. it is the default clientId and there is no any SIM card at any client.
+
+      if (_ril.getRadioInterface(clientId).isCardPresent()) {
+        return true;
+      }
+
+      numCards = numCards == null ? this._getNumCards() : numCards;
+      if (clientId === HW_DEFAULT_CLIENT_ID && numCards === 0) {
+        return true;
+      }
+
+      return false;
+    },
+
+    _handleMessage: function(message) {
+      if (DEBUG) debug("RadioControl: handleMessage: " + JSON.stringify(message));
+      let clientId = message.clientId || 0;
+      let connection =
+        gMobileConnectionService.getItemByServiceId(clientId);
+      let radioState = connection && connection.radioState;
+
+      if (message.data.enabled) {
+        if (this._isRadioAbleToEnableAtClient(clientId)) {
+          this._setRadioEnabledInternal(message);
+        } else {
+          // Not really do it but respond success.
+          message.callback(message.data);
+        }
+
+        this._processNextMessage();
+      } else {
+        _request = this._setRadioEnabledInternal.bind(this, message);
+
+        // In 2G network, modem takes 35+ seconds to process deactivate data
+        // call request if device has active voice call (please see bug 964974
+        // for more details). Therefore we should hangup all active voice calls
+        // first. And considering some DSDS architecture, toggling one radio may
+        // toggle both, so we send hangUpAll to all clients.
+        let hangUpCallback = {
+          QueryInterface: XPCOMUtils.generateQI([Ci.nsITelephonyCallback]),
+          notifySuccess: function() {},
+          notifyError: function() {}
+        };
+
+        gTelephonyService.enumerateCalls({
+          QueryInterface: XPCOMUtils.generateQI([Ci.nsITelephonyListener]),
+          enumerateCallState: function(aInfo) {
+            gTelephonyService.hangUpCall(aInfo.clientId, aInfo.callIndex,
+                                         hangUpCallback);
+          },
+          enumerateCallStateComplete: function() {}
+        });
+
+        // In some DSDS architecture with only one modem, toggling one radio may
+        // toggle both. Therefore, for safely turning off, we should first
+        // explicitly deactivate all data calls from all clients.
+        this._deactivateDataCalls().then(() => {
+          if (DEBUG) debug("RadioControl: deactivation done");
+          this._executeRequest();
+        });
+
+        this._createTimer();
+      }
+    },
+
+    _setRadioEnabledInternal: function(message) {
+      let clientId = message.clientId || 0;
+      let enabled = message.data.enabled || false;
+      let radioInterface = _ril.getRadioInterface(clientId);
+
+      radioInterface.workerMessenger.send("setRadioEnabled", message.data,
+                                          (function(response) {
+        if (response.errorMsg) {
+          // If request fails, set current radio state to unknown, since we will
+          // handle it in |mobileConnectionService|.
+          this.notifyRadioStateChanged(clientId,
+                                       Ci.nsIMobileConnection.MOBILE_RADIO_STATE_UNKNOWN);
+        }
+        return message.callback(response);
+      }).bind(this));
+    },
+
+    _deactivateDataCalls: function() {
+      if (DEBUG) debug("RadioControl: deactivating data calls...");
+      _deactivatingDeferred = {};
+
+      let promise = Promise.resolve();
+      for (let i = 0, N = _ril.numRadioInterfaces; i < N; ++i) {
+        promise = promise.then(this._deactivateDataCallsForClient(i));
+      }
+
+      return promise;
+    },
+
+    _deactivateDataCallsForClient: function(clientId) {
+      return function() {
+        let deferred = _deactivatingDeferred[clientId] = Promise.defer();
+        let dataCallHandler = gDataCallManager.getDataCallHandler(clientId);
+
+        dataCallHandler.deactivateDataCalls(function() {
+          deferred.resolve();
+        });
+
+        return deferred.promise;
+      };
+    },
+
+    _createTimer: function() {
+      if (!_timer) {
+        _timer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer);
+      }
+      _timer.initWithCallback(this._executeRequest.bind(this),
+                              RADIO_POWER_OFF_TIMEOUT,
+                              Ci.nsITimer.TYPE_ONE_SHOT);
+    },
+
+    _cancelTimer: function() {
+      if (_timer) {
+        _timer.cancel();
+      }
+    },
+
+    _executeRequest: function() {
+      if (typeof _request === "function") {
+        if (DEBUG) debug("RadioControl: executeRequest");
+        this._cancelTimer();
+        _request();
+        _request = null;
+      }
+      this._processNextMessage();
+    },
+  };
+});
+
+// Initialize shared preference "ril.numRadioInterfaces" according to system
+// property.
+try {
+  Services.prefs.setIntPref(kPrefRilNumRadioInterfaces, (function() {
+    // When Gonk property "ro.moz.ril.numclients" is not set, return 1; if
+    // explicitly set to any number larger-equal than 0, return num; else, return
+    // 1 for compatibility.
+    try {
+      let numString = libcutils.property_get("ro.moz.ril.numclients", "1");
+      let num = parseInt(numString, 10);
+      if (num >= 0) {
+        return num;
+      }
+    } catch (e) {}
+
+    return 1;
+  })());
+} catch (e) {}
+
+function DataCall(aAttributes) {
+  for (let key in aAttributes) {
+    if (key === "pdpType") {
+      // Convert pdp type into constant int value.
+      this[key] = RIL.RIL_DATACALL_PDP_TYPES.indexOf(aAttributes[key]);
+      continue;
+    }
+
+    this[key] = aAttributes[key];
+  }
+}
+DataCall.prototype = {
+  QueryInterface: XPCOMUtils.generateQI([Ci.nsIDataCall]),
+
+  failCause: Ci.nsIDataCallInterface.DATACALL_FAIL_NONE,
+  suggestedRetryTime: -1,
+  cid: -1,
+  active: -1,
+  pdpType: -1,
+  ifname: null,
+  addreses: null,
+  dnses: null,
+  gateways: null,
+  pcscf: null,
+  mtu: -1
+};
+
+function RadioInterfaceLayer() {
+  let workerMessenger = new WorkerMessenger();
+  workerMessenger.init();
+  this.setWorkerDebugFlag = workerMessenger.setDebugFlag.bind(workerMessenger);
+
+  let numIfaces = this.numRadioInterfaces;
+  if (DEBUG) debug(numIfaces + " interfaces");
+  this.radioInterfaces = [];
+  for (let clientId = 0; clientId < numIfaces; clientId++) {
+    this.radioInterfaces.push(new RadioInterface(clientId, workerMessenger));
+  }
+
+  Services.obs.addObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID, false);
+  Services.prefs.addObserver(kPrefRilDebuggingEnabled, this, false);
+
+  gRadioEnabledController.init(this);
+}
+RadioInterfaceLayer.prototype = {
+
+  classID:   RADIOINTERFACELAYER_CID,
+  classInfo: XPCOMUtils.generateCI({classID: RADIOINTERFACELAYER_CID,
+                                    classDescription: "RadioInterfaceLayer",
+                                    interfaces: [Ci.nsIRadioInterfaceLayer]}),
+
+  QueryInterface: XPCOMUtils.generateQI([Ci.nsIRadioInterfaceLayer,
+                                         Ci.nsIObserver]),
+
+  /**
+   * nsIObserver interface methods.
+   */
+
+  observe: function(subject, topic, data) {
+    switch (topic) {
+      case NS_XPCOM_SHUTDOWN_OBSERVER_ID:
+        for (let radioInterface of this.radioInterfaces) {
+          radioInterface.shutdown();
+        }
+        this.radioInterfaces = null;
+        Services.obs.removeObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID);
+        break;
+
+      case NS_PREFBRANCH_PREFCHANGE_TOPIC_ID:
+        if (data === kPrefRilDebuggingEnabled) {
+          updateDebugFlag();
+          this.setWorkerDebugFlag(DEBUG);
+        }
+        break;
+    }
+  },
+
+  /**
+   * nsIRadioInterfaceLayer interface methods.
+   */
+
+  getRadioInterface: function(clientId) {
+    return this.radioInterfaces[clientId];
+  },
+
+  setMicrophoneMuted: function(muted) {
+    for (let clientId = 0; clientId < this.numRadioInterfaces; clientId++) {
+      let radioInterface = this.radioInterfaces[clientId];
+      radioInterface.workerMessenger.send("setMute", { muted: muted });
+    }
+  }
+};
+
+XPCOMUtils.defineLazyGetter(RadioInterfaceLayer.prototype,
+                            "numRadioInterfaces", function() {
+  try {
+    return Services.prefs.getIntPref(kPrefRilNumRadioInterfaces);
+  } catch(e) {}
+
+  return 1;
+});
+
+function WorkerMessenger() {
+  // Initial owning attributes.
+  this.radioInterfaces = [];
+  this.tokenCallbackMap = {};
+
+  this.worker = new ChromeWorker("resource://gre/modules/ril_worker.js");
+  this.worker.onerror = this.onerror.bind(this);
+  this.worker.onmessage = this.onmessage.bind(this);
+}
+WorkerMessenger.prototype = {
+  radioInterfaces: null,
+  worker: null,
+
+  // This gets incremented each time we send out a message.
+  token: 1,
+
+  // Maps tokens we send out with messages to the message callback.
+  tokenCallbackMap: null,
+
+  init: function() {
+    let options = {
+      debug: DEBUG,
+      quirks: {
+        callstateExtraUint32:
+          libcutils.property_get("ro.moz.ril.callstate_extra_int", "false") === "true",
+        requestUseDialEmergencyCall:
+          libcutils.property_get("ro.moz.ril.dial_emergency_call", "false") === "true",
+        simAppStateExtraFields:
+          libcutils.property_get("ro.moz.ril.simstate_extra_field", "false") === "true",
+        extraUint2ndCall:
+          libcutils.property_get("ro.moz.ril.extra_int_2nd_call", "false") === "true",
+        haveQueryIccLockRetryCount:
+          libcutils.property_get("ro.moz.ril.query_icc_count", "false") === "true",
+        sendStkProfileDownload:
+          libcutils.property_get("ro.moz.ril.send_stk_profile_dl", "false") === "true",
+        smscAddressFormat:
+          libcutils.property_get("ro.moz.ril.smsc_address_format", "text"),
+        dataRegistrationOnDemand:
+          libcutils.property_get("ro.moz.ril.data_reg_on_demand", "false") === "true",
+        subscriptionControl:
+          libcutils.property_get("ro.moz.ril.subscription_control", "false") === "true",
+        signalExtraInt:
+          libcutils.property_get("ro.moz.ril.signal_extra_int", "false") === "true",
+        availableNetworkExtraStr:
+          libcutils.property_get("ro.moz.ril.avlbl_nw_extra_str", "false") === "true",
+      }
+    };
+
+    this.send(null, "setInitialOptions", options);
+  },
+
+  setDebugFlag: function(aDebug) {
+    let options = { debug: aDebug };
+    this.send(null, "setDebugFlag", options);
+  },
+
+  debug: function(aClientId, aMessage) {
+    // We use the same debug subject with RadioInterface's here.
+    dump("-*- RadioInterface[" + aClientId + "]: " + aMessage + "\n");
+  },
+
+  onerror: function(event) {
+    if (DEBUG) {
+      this.debug("X", "Got an error: " + event.filename + ":" +
+                 event.lineno + ": " + event.message + "\n");
+    }
+    event.preventDefault();
+  },
+
+  /**
+   * Process the incoming message from the RIL worker.
+   */
+  onmessage: function(event) {
+    let message = event.data;
+    let clientId = message.rilMessageClientId;
+    if (clientId === null) {
+      return;
+    }
+
+    if (DEBUG) {
+      this.debug(clientId, "Received message from worker: " + JSON.stringify(message));
+    }
+
+    let token = message.rilMessageToken;
+    if (token == null) {
+      // That's an unsolicited message.  Pass to RadioInterface directly.
+      let radioInterface = this.radioInterfaces[clientId];
+      radioInterface.handleUnsolicitedWorkerMessage(message);
+      return;
+    }
+
+    let callback = this.tokenCallbackMap[message.rilMessageToken];
+    if (!callback) {
+      if (DEBUG) this.debug(clientId, "Ignore orphan token: " + message.rilMessageToken);
+      return;
+    }
+
+    let keep = false;
+    try {
+      keep = callback(message);
+    } catch(e) {
+      if (DEBUG) this.debug(clientId, "callback throws an exception: " + e);
+    }
+
+    if (!keep) {
+      delete this.tokenCallbackMap[message.rilMessageToken];
+    }
+  },
+
+  registerClient: function(aClientId, aRadioInterface) {
+    if (DEBUG) this.debug(aClientId, "Starting RIL Worker");
+
+    // Keep a reference so that we can dispatch unsolicited messages to it.
+    this.radioInterfaces[aClientId] = aRadioInterface;
+
+    this.send(null, "registerClient", { clientId: aClientId });
+    gSystemWorkerManager.registerRilWorker(aClientId, this.worker);
+  },
+
+  /**
+   * Send arbitrary message to worker.
+   *
+   * @param rilMessageType
+   *        A text message type.
+   * @param message [optional]
+   *        An optional message object to send.
+   * @param callback [optional]
+   *        An optional callback function which is called when worker replies
+   *        with an message containing a "rilMessageToken" attribute of the
+   *        same value we passed.  This callback function accepts only one
+   *        parameter -- the reply from worker.  It also returns a boolean
+   *        value true to keep current token-callback mapping and wait for
+   *        another worker reply, or false to remove the mapping.
+   */
+  send: function(clientId, rilMessageType, message, callback) {
+    message = message || {};
+
+    message.rilMessageClientId = clientId;
+    message.rilMessageToken = this.token;
+    this.token++;
+
+    if (callback) {
+      // Only create the map if callback is provided.  For sending a request
+      // and intentionally leaving the callback undefined, that reply will
+      // be dropped in |this.onmessage| because of that orphan token.
+      //
+      // For sending a request that never replied at all, we're fine with this
+      // because no callback shall be passed and we leave nothing to be cleaned
+      // up later.
+      this.tokenCallbackMap[message.rilMessageToken] = callback;
+    }
+
+    message.rilMessageType = rilMessageType;
+    this.worker.postMessage(message);
+  }
+};
+
+function RadioInterface(aClientId, aWorkerMessenger) {
+  this.clientId = aClientId;
+  this.workerMessenger = {
+    send: aWorkerMessenger.send.bind(aWorkerMessenger, aClientId)
+  };
+  aWorkerMessenger.registerClient(aClientId, this);
+
+  this.operatorInfo = {};
+
+  let lock = gSettingsService.createLock();
+
+  // Read the "time.clock.automatic-update.enabled" setting to see if
+  // we need to adjust the system clock time by NITZ or SNTP.
+  lock.get(kSettingsClockAutoUpdateEnabled, this);
+
+  // Read the "time.timezone.automatic-update.enabled" setting to see if
+  // we need to adjust the system timezone by NITZ.
+  lock.get(kSettingsTimezoneAutoUpdateEnabled, this);
+
+  // Set "time.clock.automatic-update.available" to false when starting up.
+  this.setClockAutoUpdateAvailable(false);
+
+  // Set "time.timezone.automatic-update.available" to false when starting up.
+  this.setTimezoneAutoUpdateAvailable(false);
+
+  Services.obs.addObserver(this, kMozSettingsChangedObserverTopic, false);
+  Services.obs.addObserver(this, kSysClockChangeObserverTopic, false);
+  Services.obs.addObserver(this, kScreenStateChangedTopic, false);
+
+  Services.obs.addObserver(this, kNetworkConnStateChangedTopic, false);
+
+  this._sntp = new Sntp(this.setClockBySntp.bind(this),
+                        Services.prefs.getIntPref("network.sntp.maxRetryCount"),
+                        Services.prefs.getIntPref("network.sntp.refreshPeriod"),
+                        Services.prefs.getIntPref("network.sntp.timeout"),
+                        Services.prefs.getCharPref("network.sntp.pools").split(";"),
+                        Services.prefs.getIntPref("network.sntp.port"));
+}
+
+RadioInterface.prototype = {
+
+  classID:   RADIOINTERFACE_CID,
+  classInfo: XPCOMUtils.generateCI({classID: RADIOINTERFACE_CID,
+                                    classDescription: "RadioInterface",
+                                    interfaces: [Ci.nsIRadioInterface]}),
+
+  QueryInterface: XPCOMUtils.generateQI([Ci.nsIRadioInterface,
+                                         Ci.nsIObserver,
+                                         Ci.nsISettingsServiceCallback]),
+
+  // A private wrapped WorkerMessenger instance.
+  workerMessenger: null,
+
+  debug: function(s) {
+    dump("-*- RadioInterface[" + this.clientId + "]: " + s + "\n");
+  },
+
+  shutdown: function() {
+    Services.obs.removeObserver(this, kMozSettingsChangedObserverTopic);
+    Services.obs.removeObserver(this, kSysClockChangeObserverTopic);
+    Services.obs.removeObserver(this, kScreenStateChangedTopic);
+    Services.obs.removeObserver(this, kNetworkConnStateChangedTopic);
+  },
+
+  isCardPresent: function() {
+    let icc = gIccService.getIccByServiceId(this.clientId);
+    let cardState = icc ? icc.cardState : Ci.nsIIcc.CARD_STATE_UNKNOWN;
+    return cardState !== Ci.nsIIcc.CARD_STATE_UNDETECTED &&
+      cardState !== Ci.nsIIcc.CARD_STATE_UNKNOWN;
+  },
+
+  handleUnsolicitedWorkerMessage: function(message) {
+    switch (message.rilMessageType) {
+      case "callRing":
+        gTelephonyService.notifyCallRing();
+        break;
+      case "currentCalls":
+        gTelephonyService.notifyCurrentCalls(this.clientId, message.calls);
+        break;
+      case "cdmaCallWaiting":
+        gTelephonyService.notifyCdmaCallWaiting(this.clientId,
+                                                message.waitingCall);
+        break;
+      case "suppSvcNotification":
+        gTelephonyService.notifySupplementaryService(this.clientId,
+                                                     message.number,
+                                                     message.notification);
+        break;
+      case "ussdreceived":
+        gTelephonyService.notifyUssdReceived(this.clientId, message.message,
+                                             message.sessionEnded);
+        break;
+      case "datacalllistchanged":
+        let dataCalls = message.datacalls.map(dataCall => new DataCall(dataCall));
+        gDataCallInterfaceService.notifyDataCallListChanged(this.clientId,
+                                                            dataCalls.length,
+                                                            dataCalls);
+        break;
+      case "emergencyCbModeChange":
+        gMobileConnectionService.notifyEmergencyCallbackModeChanged(this.clientId,
+                                                                    message.active,
+                                                                    message.timeoutMs);
+        break;
+      case "networkinfochanged":
+        gMobileConnectionService.notifyNetworkInfoChanged(this.clientId,
+                                                          message);
+        break;
+      case "networkselectionmodechange":
+        gMobileConnectionService.notifyNetworkSelectModeChanged(this.clientId,
+                                                                message.mode);
+        break;
+      case "voiceregistrationstatechange":
+        gMobileConnectionService.notifyVoiceInfoChanged(this.clientId, message);
+        break;
+      case "dataregistrationstatechange":
+        gMobileConnectionService.notifyDataInfoChanged(this.clientId, message);
+        break;
+      case "signalstrengthchange":
+        gMobileConnectionService.notifySignalStrengthChanged(this.clientId,
+                                                             message);
+        break;
+      case "operatorchange":
+        gMobileConnectionService.notifyOperatorChanged(this.clientId, message);
+        break;
+      case "otastatuschange":
+        gMobileConnectionService.notifyOtaStatusChanged(this.clientId, message.status);
+        break;
+      case "deviceidentitieschange":
+        gMobileConnectionService.notifyDeviceIdentitiesChanged(this.clientId,
+                                                               message.deviceIdentities.imei,
+                                                               message.deviceIdentities.imeisv,
+                                                               message.deviceIdentities.esn,
+                                                               message.deviceIdentities.meid);
+        break;
+      case "radiostatechange":
+        // gRadioEnabledController should know the radio state for each client,
+        // so notify gRadioEnabledController here.
+        gRadioEnabledController.notifyRadioStateChanged(this.clientId,
+                                                        message.radioState);
+        break;
+      case "cardstatechange":
+        gIccService.notifyCardStateChanged(this.clientId,
+                                           message.cardState);
+        gRadioEnabledController.receiveCardState(this.clientId);
+        break;
+      case "sms-received":
+        this.handleSmsReceived(message);
+        break;
+      case "cellbroadcast-received":
+        this.handleCellbroadcastMessageReceived(message);
+        break;
+      case "nitzTime":
+        this.handleNitzTime(message);
+        break;
+      case "iccinfochange":
+        gIccService.notifyIccInfoChanged(this.clientId,
+                                         message.iccid ? message : null);
+        break;
+      case "iccimsi":
+        gIccService.notifyImsiChanged(this.clientId, message.imsi);
+        break;
+      case "iccmbdn":
+        this.handleIccMbdn(message);
+        break;
+      case "iccmwis":
+        this.handleIccMwis(message.mwi);
+        break;
+      case "stkcommand":
+        gIccService.notifyStkCommand(this.clientId,
+                                     gStkCmdFactory.createCommand(message));
+        break;
+      case "stksessionend":
+        gIccService.notifyStkSessionEnd(this.clientId);
+        break;
+      case "cdma-info-rec-received":
+        this.handleCdmaInformationRecords(message.records);
+        break;
+      default:
+        throw new Error("Don't know about this message type: " +
+                        message.rilMessageType);
+    }
+  },
+
+  setDataRegistration: function(attach) {
+    let deferred = Promise.defer();
+    this.workerMessenger.send("setDataRegistration",
+                              {attach: attach},
+                              (function(response) {
+      // Always resolve to proceed with the following steps.
+      deferred.resolve(response.errorMsg ? response.errorMsg : null);
+    }).bind(this));
+
+    return deferred.promise;
+  },
+
+  /**
+   * TODO: Bug 911713 - B2G NetworkManager: Move policy control logic to
+   *                    NetworkManager
+   */
+  updateRILNetworkInterface: function() {
+    let connHandler = gDataCallManager.getDataCallHandler(this.clientId);
+    connHandler.updateRILNetworkInterface();
+  },
+
+  /**
+   * handle received SMS.
+   */
+  handleSmsReceived: function(aMessage) {
+    let header = aMessage.header;
+    // Concatenation Info:
+    // - segmentRef: a modulo 256 counter indicating the reference number for a
+    //               particular concatenated short message. '0' is a valid number.
+    // - The concatenation info will not be available in |header| if
+    //   segmentSeq or segmentMaxSeq is 0.
+    // See 3GPP TS 23.040, 9.2.3.24.1 Concatenated Short Messages.
+    let segmentRef = (header && header.segmentRef !== undefined)
+      ? header.segmentRef : 1;
+    let segmentSeq = header && header.segmentSeq || 1;
+    let segmentMaxSeq = header && header.segmentMaxSeq || 1;
+    // Application Ports:
+    // The port number ranges from 0 to 49151.
+    // see 3GPP TS 23.040, 9.2.3.24.3/4 Application Port Addressing.
+    let originatorPort = (header && header.originatorPort !== undefined)
+      ? header.originatorPort
+      : Ci.nsIGonkSmsService.SMS_APPLICATION_PORT_INVALID;
+    let destinationPort = (header && header.destinationPort !== undefined)
+      ? header.destinationPort
+      : Ci.nsIGonkSmsService.SMS_APPLICATION_PORT_INVALID;
+    // MWI info:
+    let mwiPresent = (aMessage.mwi)? true : false;
+    let mwiDiscard = (mwiPresent)? aMessage.mwi.discard: false;
+    let mwiMsgCount = (mwiPresent)? aMessage.mwi.msgCount: 0;
+    let mwiActive = (mwiPresent)? aMessage.mwi.active: false;
+    // CDMA related attributes:
+    let cdmaMessageType = aMessage.messageType || 0;
+    let cdmaTeleservice = aMessage.teleservice || 0;
+    let cdmaServiceCategory = aMessage.serviceCategory || 0;
+
+    gSmsService
+      .notifyMessageReceived(this.clientId,
+                             aMessage.SMSC || null,
+                             aMessage.sentTimestamp,
+                             aMessage.sender,
+                             aMessage.pid,
+                             aMessage.encoding,
+                             RIL.GECKO_SMS_MESSAGE_CLASSES
+                               .indexOf(aMessage.messageClass),
+                             aMessage.language || null,
+                             segmentRef,
+                             segmentSeq,
+                             segmentMaxSeq,
+                             originatorPort,
+                             destinationPort,
+                             mwiPresent,
+                             mwiDiscard,
+                             mwiMsgCount,
+                             mwiActive,
+                             cdmaMessageType,
+                             cdmaTeleservice,
+                             cdmaServiceCategory,
+                             aMessage.body || null,
+                             aMessage.data || [],
+                             (aMessage.data) ? aMessage.data.length : 0);
+  },
+
+  /**
+   * Set the setting value of "time.clock.automatic-update.available".
+   */
+  setClockAutoUpdateAvailable: function(value) {
+    gSettingsService.createLock().set(kSettingsClockAutoUpdateAvailable, value, null);
+  },
+
+  /**
+   * Set the setting value of "time.timezone.automatic-update.available".
+   */
+  setTimezoneAutoUpdateAvailable: function(value) {
+    gSettingsService.createLock().set(kSettingsTimezoneAutoUpdateAvailable, value, null);
+  },
+
+  /**
+   * Set the system clock by NITZ.
+   */
+  setClockByNitz: function(message) {
+    // To set the system clock time. Note that there could be a time diff
+    // between when the NITZ was received and when the time is actually set.
+    gTimeService.set(
+      message.networkTimeInMS + (Date.now() - message.receiveTimeInMS));
+  },
+
+  /**
+   * Set the system time zone by NITZ.
+   */
+  setTimezoneByNitz: function(message) {
+    // To set the sytem timezone. Note that we need to convert the time zone
+    // value to a UTC repesentation string in the format of "UTC(+/-)hh:mm".
+    // Ex, time zone -480 is "UTC+08:00"; time zone 630 is "UTC-10:30".
+    //
+    // We can unapply the DST correction if we want the raw time zone offset:
+    // message.networkTimeZoneInMinutes -= message.networkDSTInMinutes;
+    if (message.networkTimeZoneInMinutes != (new Date()).getTimezoneOffset()) {
+      let absTimeZoneInMinutes = Math.abs(message.networkTimeZoneInMinutes);
+      let timeZoneStr = "UTC";
+      timeZoneStr += (message.networkTimeZoneInMinutes > 0 ? "-" : "+");
+      timeZoneStr += ("0" + Math.floor(absTimeZoneInMinutes / 60)).slice(-2);
+      timeZoneStr += ":";
+      timeZoneStr += ("0" + absTimeZoneInMinutes % 60).slice(-2);
+      gSettingsService.createLock().set("time.timezone", timeZoneStr, null);
+    }
+  },
+
+  /**
+   * Handle the NITZ message.
+   */
+  handleNitzTime: function(message) {
+    // Got the NITZ info received from the ril_worker.
+    this.setClockAutoUpdateAvailable(true);
+    this.setTimezoneAutoUpdateAvailable(true);
+
+    // Cache the latest NITZ message whenever receiving it.
+    this._lastNitzMessage = message;
+
+    // Set the received NITZ clock if the setting is enabled.
+    if (this._clockAutoUpdateEnabled) {
+      this.setClockByNitz(message);
+    }
+    // Set the received NITZ timezone if the setting is enabled.
+    if (this._timezoneAutoUpdateEnabled) {
+      this.setTimezoneByNitz(message);
+    }
+  },
+
+  /**
+   * Set the system clock by SNTP.
+   */
+  setClockBySntp: function(offset) {
+    // Got the SNTP info.
+    this.setClockAutoUpdateAvailable(true);
+    if (!this._clockAutoUpdateEnabled) {
+      return;
+    }
+    if (this._lastNitzMessage) {
+      if (DEBUG) debug("SNTP: NITZ available, discard SNTP");
+      return;
+    }
+    gTimeService.set(Date.now() + offset);
+  },
+
+  handleIccMbdn: function(message) {
+    let service = Cc["@mozilla.org/voicemail/voicemailservice;1"]
+                  .getService(Ci.nsIGonkVoicemailService);
+    service.notifyInfoChanged(this.clientId, message.number, message.alphaId);
+  },
+
+  handleIccMwis: function(mwi) {
+    let service = Cc["@mozilla.org/voicemail/voicemailservice;1"]
+                  .getService(Ci.nsIGonkVoicemailService);
+    // Note: returnNumber and returnMessage is not available from UICC.
+    service.notifyStatusChanged(this.clientId, mwi.active, mwi.msgCount,
+                                null, null);
+  },
+
+  _convertCbGsmGeographicalScope: function(aGeographicalScope) {
+    return (aGeographicalScope != null)
+      ? aGeographicalScope
+      : Ci.nsICellBroadcastService.GSM_GEOGRAPHICAL_SCOPE_INVALID;
+  },
+
+  _convertCbMessageClass: function(aMessageClass) {
+    let index = RIL.GECKO_SMS_MESSAGE_CLASSES.indexOf(aMessageClass);
+    return (index != -1)
+      ? index
+      : Ci.nsICellBroadcastService.GSM_MESSAGE_CLASS_NORMAL;
+  },
+
+  _convertCbEtwsWarningType: function(aWarningType) {
+    return (aWarningType != null)
+      ? aWarningType
+      : Ci.nsICellBroadcastService.GSM_ETWS_WARNING_INVALID;
+  },
+
+  handleCellbroadcastMessageReceived: function(aMessage) {
+    let etwsInfo = aMessage.etws;
+    let hasEtwsInfo = etwsInfo != null;
+    let serviceCategory = (aMessage.serviceCategory)
+      ? aMessage.serviceCategory
+      : Ci.nsICellBroadcastService.CDMA_SERVICE_CATEGORY_INVALID;
+
+    gCellBroadcastService
+      .notifyMessageReceived(this.clientId,
+                             this._convertCbGsmGeographicalScope(aMessage.geographicalScope),
+                             aMessage.messageCode,
+                             aMessage.messageId,
+                             aMessage.language,
+                             aMessage.fullBody,
+                             this._convertCbMessageClass(aMessage.messageClass),
+                             Date.now(),
+                             serviceCategory,
+                             hasEtwsInfo,
+                             (hasEtwsInfo)
+                               ? this._convertCbEtwsWarningType(etwsInfo.warningType)
+                               : Ci.nsICellBroadcastService.GSM_ETWS_WARNING_INVALID,
+                             hasEtwsInfo ? etwsInfo.emergencyUserAlert : false,
+                             hasEtwsInfo ? etwsInfo.popup : false);
+  },
+
+  handleCdmaInformationRecords: function(aRecords) {
+    if (DEBUG) this.debug("cdma-info-rec-received: " + JSON.stringify(aRecords));
+
+    let clientId = this.clientId;
+
+    aRecords.forEach(function(aRecord) {
+      if (aRecord.display) {
+        gMobileConnectionService
+          .notifyCdmaInfoRecDisplay(clientId, aRecord.display);
+        return;
+      }
+
+      if (aRecord.calledNumber) {
+        gMobileConnectionService
+          .notifyCdmaInfoRecCalledPartyNumber(clientId,
+                                              aRecord.calledNumber.type,
+                                              aRecord.calledNumber.plan,
+                                              aRecord.calledNumber.number,
+                                              aRecord.calledNumber.pi,
+                                              aRecord.calledNumber.si);
+        return;
+      }
+
+      if (aRecord.callingNumber) {
+        gMobileConnectionService
+          .notifyCdmaInfoRecCallingPartyNumber(clientId,
+                                               aRecord.callingNumber.type,
+                                               aRecord.callingNumber.plan,
+                                               aRecord.callingNumber.number,
+                                               aRecord.callingNumber.pi,
+                                               aRecord.callingNumber.si);
+        return;
+      }
+
+      if (aRecord.connectedNumber) {
+        gMobileConnectionService
+          .notifyCdmaInfoRecConnectedPartyNumber(clientId,
+                                                 aRecord.connectedNumber.type,
+                                                 aRecord.connectedNumber.plan,
+                                                 aRecord.connectedNumber.number,
+                                                 aRecord.connectedNumber.pi,
+                                                 aRecord.connectedNumber.si);
+        return;
+      }
+
+      if (aRecord.signal) {
+        gMobileConnectionService
+          .notifyCdmaInfoRecSignal(clientId,
+                                   aRecord.signal.type,
+                                   aRecord.signal.alertPitch,
+                                   aRecord.signal.signal);
+        return;
+      }
+
+      if (aRecord.redirect) {
+        gMobileConnectionService
+          .notifyCdmaInfoRecRedirectingNumber(clientId,
+                                              aRecord.redirect.type,
+                                              aRecord.redirect.plan,
+                                              aRecord.redirect.number,
+                                              aRecord.redirect.pi,
+                                              aRecord.redirect.si,
+                                              aRecord.redirect.reason);
+        return;
+      }
+
+      if (aRecord.lineControl) {
+        gMobileConnectionService
+          .notifyCdmaInfoRecLineControl(clientId,
+                                        aRecord.lineControl.polarityIncluded,
+                                        aRecord.lineControl.toggle,
+                                        aRecord.lineControl.reverse,
+                                        aRecord.lineControl.powerDenial);
+        return;
+      }
+
+      if (aRecord.clirCause) {
+        gMobileConnectionService
+          .notifyCdmaInfoRecClir(clientId,
+                                 aRecord.clirCause);
+        return;
+      }
+
+      if (aRecord.audioControl) {
+        gMobileConnectionService
+          .notifyCdmaInfoRecAudioControl(clientId,
+                                         aRecord.audioControl.upLink,
+                                         aRecord.audioControl.downLink);
+        return;
+      }
+    });
+  },
+
+  // nsIObserver
+
+  observe: function(subject, topic, data) {
+    switch (topic) {
+      case kMozSettingsChangedObserverTopic:
+        if ("wrappedJSObject" in subject) {
+          subject = subject.wrappedJSObject;
+        }
+        this.handleSettingsChange(subject.key, subject.value, subject.isInternalChange);
+        break;
+      case kSysClockChangeObserverTopic:
+        let offset = parseInt(data, 10);
+        if (this._lastNitzMessage) {
+          this._lastNitzMessage.receiveTimeInMS += offset;
+        }
+        this._sntp.updateOffset(offset);
+        break;
+      case kNetworkConnStateChangedTopic:
+        let networkInfo = subject.QueryInterface(Ci.nsINetworkInfo);
+        if (networkInfo.state != Ci.nsINetworkInfo.NETWORK_STATE_CONNECTED) {
+          return;
+        }
+
+        // SNTP can only update when we have mobile or Wifi connections.
+        if (networkInfo.type != NETWORK_TYPE_WIFI &&
+            networkInfo.type != NETWORK_TYPE_MOBILE) {
+          return;
+        }
+
+        // If the network comes from RIL, make sure the RIL service is matched.
+        if (subject instanceof Ci.nsIRilNetworkInfo) {
+          networkInfo = subject.QueryInterface(Ci.nsIRilNetworkInfo);
+          if (networkInfo.serviceId != this.clientId) {
+            return;
+          }
+        }
+
+        // SNTP won't update unless the SNTP is already expired.
+        if (this._sntp.isExpired()) {
+          this._sntp.request();
+        }
+        break;
+      case kScreenStateChangedTopic:
+        this.workerMessenger.send("setScreenState", { on: (data === "on") });
+        break;
+    }
+  },
+
+  // Flag to determine whether to update system clock automatically. It
+  // corresponds to the "time.clock.automatic-update.enabled" setting.
+  _clockAutoUpdateEnabled: null,
+
+  // Flag to determine whether to update system timezone automatically. It
+  // corresponds to the "time.clock.automatic-update.enabled" setting.
+  _timezoneAutoUpdateEnabled: null,
+
+  // Remember the last NITZ message so that we can set the time based on
+  // the network immediately when users enable network-based time.
+  _lastNitzMessage: null,
+
+  // Object that handles SNTP.
+  _sntp: null,
+
+  // Cell Broadcast settings values.
+  _cellBroadcastSearchList: null,
+
+  handleSettingsChange: function(aName, aResult, aIsInternalSetting) {
+    // Don't allow any content processes to modify the setting
+    // "time.clock.automatic-update.available" except for the chrome process.
+    if (aName === kSettingsClockAutoUpdateAvailable &&
+        !aIsInternalSetting) {
+      let isClockAutoUpdateAvailable = this._lastNitzMessage !== null ||
+                                       this._sntp.isAvailable();
+      if (aResult !== isClockAutoUpdateAvailable) {
+        if (DEBUG) {
+          debug("Content processes cannot modify 'time.clock.automatic-update.available'. Restore!");
+        }
+        // Restore the setting to the current value.
+        this.setClockAutoUpdateAvailable(isClockAutoUpdateAvailable);
+      }
+    }
+
+    // Don't allow any content processes to modify the setting
+    // "time.timezone.automatic-update.available" except for the chrome
+    // process.
+    if (aName === kSettingsTimezoneAutoUpdateAvailable &&
+        !aIsInternalSetting) {
+      let isTimezoneAutoUpdateAvailable = this._lastNitzMessage !== null;
+      if (aResult !== isTimezoneAutoUpdateAvailable) {
+        if (DEBUG) {
+          this.debug("Content processes cannot modify 'time.timezone.automatic-update.available'. Restore!");
+        }
+        // Restore the setting to the current value.
+        this.setTimezoneAutoUpdateAvailable(isTimezoneAutoUpdateAvailable);
+      }
+    }
+
+    this.handle(aName, aResult);
+  },
+
+  // nsISettingsServiceCallback
+  handle: function(aName, aResult) {
+    switch(aName) {
+      case kSettingsClockAutoUpdateEnabled:
+        this._clockAutoUpdateEnabled = aResult;
+        if (!this._clockAutoUpdateEnabled) {
+          break;
+        }
+
+        // Set the latest cached NITZ time if it's available.
+        if (this._lastNitzMessage) {
+          this.setClockByNitz(this._lastNitzMessage);
+        } else if (gNetworkManager.activeNetworkInfo &&
+                   gNetworkManager.activeNetworkInfo.state ==
+                   Ci.nsINetworkInfo.NETWORK_STATE_CONNECTED) {
+          // Set the latest cached SNTP time if it's available.
+          if (!this._sntp.isExpired()) {
+            this.setClockBySntp(this._sntp.getOffset());
+          } else {
+            // Or refresh the SNTP.
+            this._sntp.request();
+          }
+        } else {
+          // Set a sane minimum time.
+          let buildTime = libcutils.property_get("ro.build.date.utc", "0") * 1000;
+          let file = FileUtils.File("/system/b2g/b2g");
+          if (file.lastModifiedTime > buildTime) {
+            buildTime = file.lastModifiedTime;
+          }
+          if (buildTime > Date.now()) {
+            gTimeService.set(buildTime);
+          }
+        }
+        break;
+      case kSettingsTimezoneAutoUpdateEnabled:
+        this._timezoneAutoUpdateEnabled = aResult;
+
+        if (this._timezoneAutoUpdateEnabled) {
+          // Apply the latest cached NITZ for timezone if it's available.
+          if (this._timezoneAutoUpdateEnabled && this._lastNitzMessage) {
+            this.setTimezoneByNitz(this._lastNitzMessage);
+          }
+        }
+        break;
+    }
+  },
+
+  handleError: function(aErrorMessage) {
+    if (DEBUG) {
+      this.debug("There was an error while reading RIL settings.");
+    }
+  },
+
+  // nsIRadioInterface
+
+  // TODO: Bug 928861 - B2G NetworkManager: Provide a more generic function
+  //                    for connecting
+  setupDataCallByType: function(networkType) {
+    let connHandler = gDataCallManager.getDataCallHandler(this.clientId);
+    connHandler.setupDataCallByType(networkType);
+  },
+
+  // TODO: Bug 928861 - B2G NetworkManager: Provide a more generic function
+  //                    for connecting
+  deactivateDataCallByType: function(networkType) {
+    let connHandler = gDataCallManager.getDataCallHandler(this.clientId);
+    connHandler.deactivateDataCallByType(networkType);
+  },
+
+  // TODO: Bug 904514 - [meta] NetworkManager enhancement
+  getDataCallStateByType: function(networkType) {
+    let connHandler = gDataCallManager.getDataCallHandler(this.clientId);
+    return connHandler.getDataCallStateByType(networkType);
+  },
+
+  sendWorkerMessage: function(rilMessageType, message, callback) {
+    // Special handler for setRadioEnabled.
+    if (rilMessageType === "setRadioEnabled") {
+      // Forward it to gRadioEnabledController.
+      gRadioEnabledController.setRadioEnabled(this.clientId, message,
+                                              callback.handleResponse);
+      return;
+    }
+
+    if (callback) {
+      this.workerMessenger.send(rilMessageType, message, function(response) {
+        return callback.handleResponse(response);
+      });
+    } else {
+      this.workerMessenger.send(rilMessageType, message);
+    }
+  },
+};
+
+this.NSGetFactory = XPCOMUtils.generateNSGetFactory([RadioInterfaceLayer]);