Add m-esr52 at 52.6.0

1 files changed, 276 insertions, 0 deletions

diff --git a/dom/system/gonk/DataCallInterfaceService.js b/dom/system/gonk/DataCallInterfaceService.js
new file mode 100644
index 000000000..0f0e7101c
--- /dev/null
+++ b/dom/system/gonk/DataCallInterfaceService.js
@@ -0,0 +1,276 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+const {classes: Cc, interfaces: Ci, utils: Cu, results: Cr} = Components;
+
+Cu.import("resource://gre/modules/Services.jsm");
+Cu.import("resource://gre/modules/XPCOMUtils.jsm");
+
+const DATACALLINTERFACE_CONTRACTID = "@mozilla.org/datacall/interface;1";
+const DATACALLINTERFACESERVICE_CONTRACTID =
+  "@mozilla.org/datacall/interfaceservice;1";
+const DATACALLINTERFACE_CID =
+  Components.ID("{ff669306-4390-462a-989b-ba37fc42153f}");
+const DATACALLINTERFACESERVICE_CID =
+  Components.ID("{e23e9337-592d-40b9-8cef-7bd47c28b72e}");
+
+const TOPIC_XPCOM_SHUTDOWN      = "xpcom-shutdown";
+const TOPIC_PREF_CHANGED        = "nsPref:changed";
+const PREF_RIL_DEBUG_ENABLED    = "ril.debugging.enabled";
+
+XPCOMUtils.defineLazyGetter(this, "RIL", function () {
+  let obj = {};
+  Cu.import("resource://gre/modules/ril_consts.js", obj);
+  return obj;
+});
+
+XPCOMUtils.defineLazyServiceGetter(this, "gRil",
+                                   "@mozilla.org/ril;1",
+                                   "nsIRadioInterfaceLayer");
+
+XPCOMUtils.defineLazyServiceGetter(this, "gMobileConnectionService",
+                                   "@mozilla.org/mobileconnection/mobileconnectionservice;1",
+                                   "nsIMobileConnectionService");
+
+var DEBUG = RIL.DEBUG_RIL;
+
+function updateDebugFlag() {
+  // Read debug setting from pref
+  let debugPref;
+  try {
+    debugPref = Services.prefs.getBoolPref(PREF_RIL_DEBUG_ENABLED);
+  } catch (e) {
+    debugPref = false;
+  }
+  DEBUG = debugPref || RIL.DEBUG_RIL;
+}
+updateDebugFlag();
+
+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 DataCallInterfaceService() {
+  this._dataCallInterfaces = [];
+
+  let numClients = gRil.numRadioInterfaces;
+  for (let i = 0; i < numClients; i++) {
+    this._dataCallInterfaces.push(new DataCallInterface(i));
+  }
+
+  Services.obs.addObserver(this, TOPIC_XPCOM_SHUTDOWN, false);
+  Services.prefs.addObserver(PREF_RIL_DEBUG_ENABLED, this, false);
+}
+DataCallInterfaceService.prototype = {
+  classID:   DATACALLINTERFACESERVICE_CID,
+  classInfo: XPCOMUtils.generateCI({
+    classID: DATACALLINTERFACESERVICE_CID,
+    contractID: DATACALLINTERFACESERVICE_CONTRACTID,
+    classDescription: "Data Call Interface Service",
+    interfaces: [Ci.nsIDataCallInterfaceService,
+                 Ci.nsIGonkDataCallInterfaceService]
+  }),
+  QueryInterface: XPCOMUtils.generateQI([Ci.nsIDataCallInterfaceService,
+                                         Ci.nsIGonkDataCallInterfaceService],
+                                         Ci.nsIObserver),
+
+  // An array of DataCallInterface instances.
+  _dataCallInterfaces: null,
+
+  debug: function(aMessage) {
+    dump("-*- DataCallInterfaceService: " + aMessage + "\n");
+  },
+
+  // nsIDataCallInterfaceService
+
+  getDataCallInterface: function(aClientId) {
+    let dataCallInterface = this._dataCallInterfaces[aClientId];
+    if (!dataCallInterface) {
+      throw Cr.NS_ERROR_UNEXPECTED;
+    }
+
+    return dataCallInterface;
+  },
+
+  // nsIGonkDataCallInterfaceService
+
+  notifyDataCallListChanged: function(aClientId, aCount, aDataCalls) {
+    let dataCallInterface = this.getDataCallInterface(aClientId);
+    dataCallInterface.handleDataCallListChanged(aCount, aDataCalls);
+  },
+
+  // nsIObserver
+
+  observe: function(aSubject, aTopic, aData) {
+    switch (aTopic) {
+      case TOPIC_PREF_CHANGED:
+        if (aData === PREF_RIL_DEBUG_ENABLED) {
+          updateDebugFlag();
+        }
+        break;
+      case TOPIC_XPCOM_SHUTDOWN:
+        Services.prefs.removeObserver(PREF_RIL_DEBUG_ENABLED, this);
+        Services.obs.removeObserver(this, TOPIC_XPCOM_SHUTDOWN);
+        break;
+    }
+  },
+};
+
+function DataCallInterface(aClientId) {
+  this._clientId = aClientId;
+  this._radioInterface = gRil.getRadioInterface(aClientId);
+  this._listeners = [];
+
+  if (DEBUG) this.debug("DataCallInterface: " + aClientId);
+}
+DataCallInterface.prototype = {
+  classID:   DATACALLINTERFACE_CID,
+  classInfo: XPCOMUtils.generateCI({classID: DATACALLINTERFACE_CID,
+                                    contractID: DATACALLINTERFACE_CONTRACTID,
+                                    classDescription: "Data Call Interface",
+                                    interfaces: [Ci.nsIDataCallInterface]}),
+  QueryInterface: XPCOMUtils.generateQI([Ci.nsIDataCallInterface]),
+
+  debug: function(aMessage) {
+    dump("-*- DataCallInterface[" + this._clientId + "]: " + aMessage + "\n");
+  },
+
+  _clientId: -1,
+
+  _radioInterface: null,
+
+  _listeners: null,
+
+  // nsIDataCallInterface
+
+  setupDataCall: function(aApn, aUsername, aPassword, aAuthType, aPdpType,
+                          aCallback) {
+    let connection =
+      gMobileConnectionService.getItemByServiceId(this._clientId);
+    let dataInfo = connection && connection.data;
+    let radioTechType = dataInfo.type;
+    let radioTechnology = RIL.GECKO_RADIO_TECH.indexOf(radioTechType);
+    // Convert pdp type into string value.
+    let pdpType = RIL.RIL_DATACALL_PDP_TYPES[aPdpType];
+
+    this._radioInterface.sendWorkerMessage("setupDataCall", {
+      radioTech: radioTechnology,
+      apn: aApn,
+      user: aUsername,
+      passwd: aPassword,
+      chappap: aAuthType,
+      pdptype: pdpType
+    }, (aResponse) => {
+      if (aResponse.errorMsg) {
+        aCallback.notifyError(aResponse.errorMsg);
+      } else {
+        let dataCall = new DataCall(aResponse);
+        aCallback.notifySetupDataCallSuccess(dataCall);
+      }
+    });
+  },
+
+  deactivateDataCall: function(aCid, aReason, aCallback) {
+    this._radioInterface.sendWorkerMessage("deactivateDataCall", {
+      cid: aCid,
+      reason: aReason
+    }, (aResponse) => {
+      if (aResponse.errorMsg) {
+        aCallback.notifyError(aResponse.errorMsg);
+      } else {
+        aCallback.notifySuccess();
+      }
+    });
+  },
+
+  getDataCallList: function(aCallback) {
+    this._radioInterface.sendWorkerMessage("getDataCallList", null,
+      (aResponse) => {
+        if (aResponse.errorMsg) {
+          aCallback.notifyError(aResponse.errorMsg);
+        } else {
+          let dataCalls = aResponse.datacalls.map(
+            dataCall => new DataCall(dataCall));
+          aCallback.notifyGetDataCallListSuccess(dataCalls.length, dataCalls);
+        }
+      });
+  },
+
+  setDataRegistration: function(aAttach, aCallback) {
+    this._radioInterface.sendWorkerMessage("setDataRegistration", {
+      attach: aAttach
+    }, (aResponse) => {
+      if (aResponse.errorMsg) {
+        aCallback.notifyError(aResponse.errorMsg);
+      } else {
+        aCallback.notifySuccess();
+      }
+    });
+  },
+
+  handleDataCallListChanged: function(aCount, aDataCalls) {
+    this._notifyAllListeners("notifyDataCallListChanged", [aCount, aDataCalls]);
+  },
+
+  _notifyAllListeners: function(aMethodName, aArgs) {
+    let listeners = this._listeners.slice();
+    for (let listener of listeners) {
+      if (this._listeners.indexOf(listener) == -1) {
+        // Listener has been unregistered in previous run.
+        continue;
+      }
+
+      let handler = listener[aMethodName];
+      try {
+        handler.apply(listener, aArgs);
+      } catch (e) {
+        if (DEBUG) {
+          this.debug("listener for " + aMethodName + " threw an exception: " + e);
+        }
+      }
+    }
+  },
+
+  registerListener: function(aListener) {
+    if (this._listeners.indexOf(aListener) >= 0) {
+      return;
+    }
+
+    this._listeners.push(aListener);
+  },
+
+  unregisterListener: function(aListener) {
+    let index = this._listeners.indexOf(aListener);
+    if (index >= 0) {
+      this._listeners.splice(index, 1);
+    }
+  },
+};
+
+this.NSGetFactory = XPCOMUtils.generateNSGetFactory([DataCallInterfaceService]);
\ No newline at end of file