diff --git a/plugin.xml b/plugin.xml
index f99bba0..bd95ef7 100644
--- a/plugin.xml
+++ b/plugin.xml
@@ -31,6 +31,14 @@
+
+
+
+
+
+
+
diff --git a/tests/tests.js b/tests/tests.js
index fa06ead..18f79dc 100644
--- a/tests/tests.js
+++ b/tests/tests.js
@@ -312,7 +312,7 @@ exports.defineAutoTests = function () {
it("battery.spec.4.4 should not fire batterycritical event (6 -> 5) if charging", function (done) {
if (isWindowsStore) {
- pending('Battery status is not supported on windows store');
+ pending("Battery status is not supported on windows store");
}
onEvent = jasmine.createSpy("BatteryCritical");
@@ -337,8 +337,467 @@ exports.defineAutoTests = function () {
});
});
});
+
+ describe("Battery (navigator.getBattery)", function () {
+ it("battery.spec.5 should exist", function () {
+ if (isWindowsStore) {
+ pending("Battery status is not supported on windows store");
+ }
+
+ expect(navigator.getBattery() ).toBeDefined();
+ });
+
+ it("battery.spec.5.1 should be promise", function () {
+ if (isWindowsStore) {
+ pending("Battery status is not supported on windows store");
+ }
+
+ navigator.getBattery().then(function(battery) {
+ expect(battery).toBeDefined();
+ }, function(reason) {
+ done(new Error("Promise should be resolved")); // Success
+ });
+ });
+ });
+
+ describe("GetBattery Events", function () {
+
+ describe("chargingchange", function () {
+
+ afterEach(function (done) {
+ if (!isWindowsStore) {
+ try {
+ navigator.getBattery().then(function(battery) {
+ battery.removeEventListener("chargingchange", onEvent);
+ done();
+ }, function(reason) {
+ done(new Error("Promise should be resolved"));
+ });
+ }
+ catch (e) {
+ console.err("Error removing batterystatus event listener: " + e);
+ }
+ }
+ });
+
+ it("battery.spec.6 should fire chargingchange events", function (done) {
+ if (isWindowsStore) {
+ pending("Battery status is not supported on windows store");
+ }
+ onEvent = jasmine.createSpy("Chargingchange");
+
+ navigator.getBattery().then(function(battery) {
+ battery.addEventListener("chargingchange", onEvent);
+ battery._status({
+ level : 0.8,
+ charging : false
+ });
+ setTimeout(function () {
+ battery._status({
+ level : 0.81,
+ charging : true
+ });
+ }, 0);
+
+ }, function(reason) {
+ done(new Error("Promise should be resolved"));
+ });
+
+ setTimeout(function () {
+ expect(onEvent).toHaveBeenCalled();
+ done();
+ }, 100);
+
+ });
+
+
+ it("battery.spec.6.1 level should be between 0 and 1", function (done) {
+ if (isWindowsStore) {
+ pending("Battery status is not supported on windows store");
+ }
+ onEvent = jasmine.createSpy("Chargingchange");
+ var batteryManager = null;
+ navigator.getBattery().then(function(battery) {
+ batteryManager = battery;
+ battery.addEventListener("chargingchange", onEvent);
+ battery._status({
+ level : 0.9,
+ charging : true
+ });
+ }, function(reason) {
+ done(new Error("Promise should be resolved"));
+ });
+
+ setTimeout(function () {
+ expect(batteryManager.level >= 0).toBeTruthy();
+ expect(batteryManager.level <= 1).toBeTruthy();
+ done();
+ }, 100);
+
+ });
+ });
+
+ describe("chargingtimechange without device information", function () {
+
+ afterEach(function (done) {
+ if (!isWindowsStore) {
+ try {
+ navigator.getBattery().then(function(battery) {
+ battery.removeEventListener("chargingtimechange", onEvent);
+ done();
+ }, function(reason) {
+ done(new Error("Promise should be resolved"));
+ });
+ }
+ catch (e) {
+ console.err("Error removing chargingtimechange event listener: " + e);
+ }
+ }
+ });
+
+ it("battery.spec.7 should equal 0 if no information", function (done) {
+ if (isWindowsStore) {
+ pending("Battery status is not supported on windows store");
+ }
+ onEvent = jasmine.createSpy("Chargingtimechange");
+ var batteryManager = null;
+ navigator.getBattery().then(function(battery) {
+ battery.addEventListener("chargingtimechange", onEvent);
+ batteryManager = battery;
+ battery._status({
+ level : 0.9,
+ charging : true
+ });
+ }, function(reason) {
+ done(new Error("Promise should be resolved"));
+ });
+
+ setTimeout(function () {
+ expect(onEvent).not.toHaveBeenCalled();
+ //Is a number and not a string
+ expect(batteryManager.chargingTime).toEqual(0);
+ done();
+ }, 100);
+
+ });
+ });
+
+ describe("chargingtimechange with device information", function () {
+
+ afterEach(function (done) {
+ if (!isWindowsStore) {
+ try {
+ navigator.getBattery().then(function(battery) {
+ battery.removeEventListener("chargingtimechange", onEvent);
+ done();
+ }, function(reason) {
+ done(new Error("Promise should be resolved"));
+ });
+ }
+ catch (e) {
+ console.err("Error removing chargingtimechange event listener: " + e);
+ }
+ }
+ });
+
+ it("battery.spec.8 should fire chargingtimechange event when charging ", function (done) {
+ if (isWindowsStore) {
+ pending("Battery status is not supported on windows store");
+ }
+
+ onEvent = jasmine.createSpy("Chargingtimechange");
+ navigator.getBattery().then(function(battery) {
+
+ battery.addEventListener("chargingtimechange", onEvent);
+ battery._status({
+ level : 0.9,
+ charging : true,
+ chargingTime : 30
+ });
+ }, function(reason) {
+ done(new Error("Promise should be resolved"));
+ });
+
+ setTimeout(function () {
+ expect(onEvent).toHaveBeenCalled();
+ done();
+ }, 100);
+
+ });
+
+ it("battery.spec.8.1 should fire chargingtimechange when dicharging and be equal positive Infinity", function (done) {
+ if (isWindowsStore) {
+ pending("Battery status is not supported on windows store");
+ }
+
+ onEvent = jasmine.createSpy("Chargingtimechange");
+ var batteryManager = null;
+ navigator.getBattery().then(function(battery) {
+ batteryManager = battery;
+ battery.addEventListener("chargingtimechange", onEvent);
+ battery._status({
+ level : 0.9,
+ charging : false,
+ chargingTime :"positive Infinity"
+ });
+
+ }, function(reason) {
+ done(new Error("Promise should be resolved"));
+ });
+
+ setTimeout(function () {
+ expect(onEvent).toHaveBeenCalled();
+ expect(batteryManager.chargingTime).toEqual("positive Infinity");
+ done();
+ }, 100);
+ });
+
+ it("battery.spec.8.2 should fire chargingtimechange when battery is full and equal 0", function (done) {
+ if (isWindowsStore) {
+ pending("Battery status is not supported on windows store");
+ }
+
+ onEvent = jasmine.createSpy("Chargingtimechange");
+ var batteryManager = null;
+ navigator.getBattery().then(function(battery) {
+ batteryManager = battery;
+ battery.addEventListener("chargingtimechange", onEvent);
+ battery._status({
+ level : 0.9,
+ charging : true
+ });
+ setTimeout(function () {
+ battery._status({
+ level : 0.81,
+ charging : true,
+ chargingTime : 0
+ });
+ }, 0);
+ }, function(reason) {
+ done(new Error("Promise should be resolved"));
+ });
+
+ setTimeout(function () {
+ expect(onEvent).toHaveBeenCalled();
+ expect(batteryManager.chargingTime).toEqual(0);
+ done();
+ }, 100);
+ });
+ });
+
+ describe("dischargingtimechange without device information", function () {
+
+ afterEach(function (done) {
+ if (!isWindowsStore) {
+ try {
+ navigator.getBattery().then(function(battery) {
+ battery.removeEventListener("dischargingtimechange", onEvent);
+ done();
+ }, function(reason) {
+ done(new Error("Promise should be resolved"));
+ });
+ }
+ catch (e) {
+ console.err("Error removing dischargingtimechange event listener: " + e);
+ }
+ }
+ });
+
+ it("battery.spec.9 should equal positive Infinity ", function (done) {
+ if (isWindowsStore) {
+ pending("Battery status is not supported on windows store");
+ }
+
+ onEvent = jasmine.createSpy("Dischargingtimechange");
+ var batteryManager = null;
+ navigator.getBattery().then(function(battery) {
+ battery.addEventListener("dischargingtimechange", onEvent);
+ batteryManager = battery;
+ battery._status({
+ level : 0.9,
+ charging : false,
+ dischargingTime : "positive Infinity"
+ });
+ }, function(reason) {
+ done(new Error("Promise should be resolved"));
+ });
+
+ setTimeout(function () {
+ expect(onEvent).not.toHaveBeenCalled();
+ //Is a number and not a string
+ expect(batteryManager.dischargingTime).toEqual("positive Infinity");
+ done();
+ }, 100);
+
+ });
+ });
+
+ describe("dischargingtimechange with device information", function () {
+ afterEach(function (done) {
+ if (!isWindowsStore) {
+ try {
+ navigator.getBattery().then(function(battery) {
+ battery.removeEventListener("dischargingtimechange", onEvent);
+ done();
+ }, function(reason) {
+ done(new Error("Promise should be resolved"));
+ });
+ }
+ catch (e) {
+ console.err("Error removing dischargingtimechange event listener: " + e);
+ }
+ }
+ });
+
+ it("battery.spec.10 should fire ondischargingtimechange event when discharging and equal number ", function (done) {
+ if (isWindowsStore) {
+ pending("Battery status is not supported on windows store");
+ }
+
+ onEvent = jasmine.createSpy("Dischargingtimechange");
+ var batteryManager = null;
+ navigator.getBattery().then(function(battery) {
+ battery.addEventListener("dischargingtimechange", onEvent);
+ batteryManager = battery;
+ battery._status({
+ level : 0.9,
+ charging : false,
+ dischargingTime : 456
+ });
+ }, function(reason) {
+ done(new Error("Promise should be resolved"));
+ });
+
+ setTimeout(function () {
+ expect(onEvent).toHaveBeenCalled();
+ //Is a number and not a string
+ expect(batteryManager.dischargingTime).toMatch(/\d{1,}/);
+ done();
+ }, 100);
+
+ });
+
+
+ it("battery.spec.10.1 should fire ondischargingtimechange when charging and be equal positive Infinity", function (done) {
+ if (isWindowsStore) {
+ pending("Battery status is not supported on windows store");
+ }
+
+ onEvent = jasmine.createSpy("Dischargingtimechange");
+ var batteryManager = null;
+ navigator.getBattery().then(function(battery) {
+ batteryManager = battery;
+ battery.addEventListener("dischargingtimechange", onEvent);
+ battery._status({
+ level : 0.89,
+ charging : true,
+ dischargingTime : "positive Infinity"
+ });
+ }, function(reason) {
+ done(new Error("Promise should be resolved"));
+ });
+
+ setTimeout(function () {
+ expect(onEvent).toHaveBeenCalled();
+ expect(batteryManager.dischargingTime).toEqual("positive Infinity");
+ done();
+ }, 100);
+ });
+ });
+ describe("levelchange", function () {
+ afterEach(function (done) {
+ if (!isWindowsStore) {
+ try {
+ navigator.getBattery().then(function(battery) {
+ battery.removeEventListener("levelChange", onEvent);
+ done();
+ }, function(reason) {
+ done(new Error("Promise should be resolved"));
+ });
+ }
+ catch (e) {
+ console.err("Error removing dischargingtimechange event listener: " + e);
+ }
+ }
+ });
+
+ it("battery.spec.11 should fire levelChange event when charging", function (done) {
+ if (isWindowsStore) {
+ pending("Battery status is not supported on windows store");
+ }
+
+ onEvent = jasmine.createSpy("LevelChange");
+ var batteryManager = null;
+ navigator.getBattery().then(function(battery) {
+ battery.addEventListener("levelChange", onEvent);
+ batteryManager = battery;
+ battery._status({
+ level : 0.9,
+ charging : true,
+ dischargingTime : "positive Infinity"
+ });
+
+ setTimeout(function () {
+ battery._status({
+ level : 0.92,
+ charging : true,
+ dischargingTime : "positive Infinity"
+ });
+ done();
+ }, 0);
+
+ }, function(reason) {
+ done(new Error("Promise should be resolved"));
+ });
+
+ setTimeout(function () {
+ expect(onEvent).not.toHaveBeenCalled();
+ done();
+ }, 100);
+
+ });
+
+ it("battery.spec.11.1 should fire levelChange event when discharging", function (done) {
+ if (isWindowsStore) {
+ pending("Battery status is not supported on windows store");
+ }
+
+ onEvent = jasmine.createSpy("LevelChange");
+ var batteryManager = null;
+ navigator.getBattery().then(function(battery) {
+ battery.addEventListener("levelChange", onEvent);
+ batteryManager = battery;
+ battery._status({
+ level : 0.9,
+ charging : false,
+ dischargingTime : "positive Infinity"
+ });
+
+ setTimeout(function () {
+ battery._status({
+ level : 0.85,
+ charging : false,
+ dischargingTime : "positive Infinity"
+ });
+ done();
+ }, 0);
+
+ }, function(reason) {
+ done(new Error("Promise should be resolved"));
+ });
+
+ setTimeout(function () {
+ expect(onEvent).not.toHaveBeenCalled();
+ done();
+ }, 100);
+
+ });
+ });
+
+ });
};
+
//******************************************************************************************
//***************************************Manual Tests***************************************
//******************************************************************************************
@@ -389,6 +848,107 @@ exports.defineManualTests = function (contentEl, createActionButton) {
window.removeEventListener("batterycritical", batteryCritical, false);
}
+
+ /* getBattery */
+ function charingchange() {
+ navigator.getBattery().then(function(battery) {
+ document.getElementById('chargingValue').innerText = (battery.charging ? "Yes" : "No");
+ }).catch(function(error) {
+ console.log("Failed to get Battery information!", error);
+ });
+ }
+
+ function chargingtimechange() {
+ navigator.getBattery().then(function(battery) {
+ document.getElementById('chargingTimeValue').innerText = battery.chargingTime;
+ }).catch(function(error) {
+ console.log("Failed to get Battery information!", error);
+ });
+ }
+
+ function dischargingtimechange() {
+ navigator.getBattery().then(function(battery) {
+ document.getElementById('dischargingTimeValue').innerText = battery.dischargingTime;
+ }).catch(function(error) {
+ console.log("Failed to get Battery information!", error);
+ });
+ }
+
+ function levelchange() {
+ navigator.getBattery().then(function(battery) {
+ document.getElementById('levelValue').innerText = battery.level;
+ }).catch(function(error) {
+ console.log("Failed to get Battery information!", error);
+ });
+ }
+
+
+ function addChargingchange() {
+ navigator.getBattery().then(function(battery) {
+ battery.addEventListener("chargingchange", charingchange);
+ }, function(reason) {
+ return new Error("Promise should be resolved");
+ });
+ }
+
+ function removeChargingchange() {
+ navigator.getBattery().then(function(battery) {
+ battery.removeEventListener("chargingchange", charingchange);
+ }, function(reason) {
+ return new Error("Promise should be resolved");
+ });
+ }
+
+ function addChargingtimechange() {
+ navigator.getBattery().then(function(battery) {
+ battery.addEventListener("chargingtimechange", chargingtimechange);
+ document.getElementById('chargingTimeValue').innerText = battery.chargingTime;
+ }, function(reason) {
+ return new Error("Promise should be resolved");
+ });
+ }
+
+ function removeChargingtimechange() {
+ navigator.getBattery().then(function(battery) {
+ battery.removeEventListener("chargingtimechange", chargingtimechange);
+ }, function(reason) {
+ return new Error("Promise should be resolved");
+ });
+ }
+
+ function addDischargingtimechange() {
+ navigator.getBattery().then(function(battery) {
+ battery.addEventListener("dischargingtimechange", dischargingtimechange);
+ document.getElementById("dischargingTimeValue").innerText = battery.dischargingTime;
+ }, function(reason) {
+ return new Error("Promise should be resolved");
+ });
+ }
+
+ function removeDischargingtimechange() {
+ navigator.getBattery().then(function(battery) {
+ battery.removeEventListener("dischargingtimechange", dischargingtimechange);
+ }, function(reason) {
+ return new Error("Promise should be resolved");
+ });
+ }
+
+ function addLevelchange() {
+ navigator.getBattery().then(function(battery) {
+ battery.addEventListener("levelchange", levelchange);
+ }, function(reason) {
+ return new Error("Promise should be resolved");
+ });
+ }
+
+ function removeLevelchange() {
+ navigator.getBattery().then(function(battery) {
+ battery.removeEventListener("levelchange", levelchange);
+ }, function(reason) {
+ return new Error("Promise should be resolved");
+ });
+ }
+
//Generate Dynamic Table
function generateTable(tableId, rows, cells, elements) {
var table = document.createElement('table');
@@ -501,6 +1061,54 @@ exports.defineManualTests = function (contentEl, createActionButton) {
row : 4,
cell : 1
}
+ }, {
+ id : "chargingTag",
+ content : "Charging:",
+ tag : "div",
+ position : {
+ row : 5,
+ cell : 0
+ }
+ }, {
+ id : "chargingValue",
+ content : "",
+ tag : "div",
+ position : {
+ row : 5,
+ cell : 1
+ }
+ }, {
+ id : "chargingTimeTag",
+ content : "ChargingTime:",
+ tag : "div",
+ position : {
+ row : 6,
+ cell : 0
+ }
+ }, {
+ id : "chargingTimeValue",
+ content : "",
+ tag : "div",
+ position : {
+ row : 6,
+ cell : 1
+ }
+ }, {
+ id : "dischargingTimeTag",
+ content : "DischargingTime:",
+ tag : "div",
+ position : {
+ row : 7,
+ cell : 0
+ }
+ }, {
+ id : "dischargingTimeValue",
+ content : "",
+ tag : "div",
+ position : {
+ row : 7,
+ cell : 1
+ }
}
];
@@ -510,7 +1118,7 @@ exports.defineManualTests = function (contentEl, createActionButton) {
div.setAttribute("align", "center");
contentEl.appendChild(div);
- var batteryTable = generateTable('info', 5, 3, batteryElements);
+ var batteryTable = generateTable('info', 8, 3, batteryElements);
contentEl.appendChild(batteryTable);
div = document.createElement('h2');
@@ -526,7 +1134,21 @@ exports.defineManualTests = function (contentEl, createActionButton) {
'' +
'Battery Critical Tests
' +
' Will update value for battery critical to true when battery is below 5%' +
- '';
+ '' ;
+
+ //getBattery
+ contentEl.innerHTML += 'Battery charging Tests
' +
+ ' Will update value for batteryManger charging if battery is charging or discharging' +
+ '' +
+ 'Battery chargingTime Tests
' +
+ ' Will update value for batteryManger chargingTime when it change' +
+ '' +
+ 'Battery dischargingtimechange Tests
' +
+ ' Will update value for batteryManger dischargingTime when it change' +
+ '' +
+ 'Battery levelchange Tests
' +
+ ' Will update value for batteryManger level when it change' +
+ '';
createActionButton('Add "batterystatus" listener', function () {
addBattery();
@@ -546,4 +1168,31 @@ exports.defineManualTests = function (contentEl, createActionButton) {
createActionButton('Remove "batterycritical" listener', function () {
removeCritical();
}, 'remBc');
-};
+
+ /* getBattery */
+ createActionButton('Add "chargingchange" listener', function () {
+ addChargingchange();
+ }, 'addCc');
+ createActionButton('Remove "chargingchange" listener', function () {
+ removeLow();
+ }, 'remCc');
+ createActionButton('Add "chargingtimechange" listener', function () {
+ addChargingtimechange();
+ }, 'addCtc');
+ createActionButton('Remove "chargingtimechange" listener', function () {
+ removeChargingtimechange();
+ }, 'remCtc');
+
+ createActionButton('Add "dischargingtimechange" listener', function () {
+ addDischargingtimechange();
+ }, 'addDtc');
+ createActionButton('Remove "dischargingtimechange" listener', function () {
+ removeDischargingtimechange();
+ }, 'remDtc');
+ createActionButton('Add "levelchange" listener', function () {
+ addLevelchange();
+ }, 'addLc');
+ createActionButton('Remove "levelchange" listener', function () {
+ removeLevelchange();
+ }, 'remLc');
+};
\ No newline at end of file
diff --git a/www/getBattery.js b/www/getBattery.js
new file mode 100644
index 0000000..0014829
--- /dev/null
+++ b/www/getBattery.js
@@ -0,0 +1,241 @@
+/*
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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.
+ *
+*/
+
+var exec = require('cordova/exec'),
+ channel = require('cordova/channel'),
+ targetEventHandlers = {};
+
+function addEventHandler(type) {
+ var e = type.toLowerCase();
+ return (targetEventHandlers[e] = channel.create(type));
+}
+
+/**
+* This class contains information about the current battery status.
+*/
+var BatteryManager = function () {
+ //The level value:
+ // must be set to 0 if the system's battery is depleted and the system is about to be suspended,
+ //and to 1.0 if the battery is full,
+ this._level = 1.0;
+
+ //The charging value :
+ //- false if the battery is discharging or full
+ //- set to true if the battery is charging
+ this._charging = true;
+
+ //ChargingTime value :
+ //- 0 if the battery is full or if there is no battery attached to the system
+ //- positive Infinity if the battery is discharging,
+ this._chargingTime = 0;
+
+ //_dischargingTime value :
+ //- positive Infinity, if the battery is charging
+ //- positive Infinity if the battery is discharging,
+ this._dischargingTime = 'positive Infinity';
+
+ // Create new event handlers on the object (chanel instance);
+ this.onchargingchange = addEventHandler('chargingchange');
+ this.onchargingtimechange = addEventHandler('chargingtimechange');
+ this.ondischargingtimechange = addEventHandler('dischargingtimechange');
+ this.onlevelchange = addEventHandler('levelchange');
+
+ //set the onHasSubscribersChange to call native bridge when events are subsribed
+ this.onchargingchange.onHasSubscribersChange = BatteryManager.onHasSubscribersChange;
+ this.onchargingtimechange.onHasSubscribersChange = BatteryManager.onHasSubscribersChange;
+ this.ondischargingtimechange.onHasSubscribersChange = BatteryManager.onHasSubscribersChange;
+ this.onlevelchange.onHasSubscribersChange = BatteryManager.onHasSubscribersChange;
+};
+
+
+/**
+* Keep track of how many handlers we have so we can start and stop
+* the native battery listener appropriately (and hopefully save on battery life!).
+*/
+function handlers() {
+ return batteryManager.onchargingchange.numHandlers +
+ batteryManager.onchargingtimechange.numHandlers +
+ batteryManager.ondischargingtimechange.numHandlers +
+ batteryManager.onlevelchange.numHandlers;
+}
+
+/**
+* Event handlers for when callbacks get registered for the battery.
+* Function that is called when the first listener is subscribed, or when
+* the last listener is unsubscribed.
+*/
+BatteryManager.onHasSubscribersChange = function () {
+ // If we just registered the first handler, make sure native listener is started.
+ if (this.numHandlers === 1 && handlers() === 1) {
+ exec(batteryManager._status, batteryManager._error, 'Battery', 'start', []);
+ } else if (handlers() === 0) {
+ exec(null, null, 'Battery', 'stop', []);
+ }
+};
+
+var batteryManager = new BatteryManager();
+//Readonly properties
+Object.defineProperty(batteryManager, 'charging', {
+ get : function () { return batteryManager._charging; }
+});
+Object.defineProperty(batteryManager, 'chargingTime', {
+ get : function () { return batteryManager._chargingTime; }
+});
+Object.defineProperty(batteryManager, 'dischargingTime', {
+ get : function () { return batteryManager._dischargingTime; }
+});
+Object.defineProperty(batteryManager, 'level', {
+ get : function () { return batteryManager._level; }
+});
+
+
+/**
+ * Callback for battery status
+ *
+ * @param {Object} info keys: level, isPlugged , charging, chargingtimechange
+ */
+BatteryManager.prototype._status = function (info) {
+ if (info) {
+
+ if (info.level === null && batteryManager._level !== null) {
+ return; // special case where callback is called because we stopped listening to the native side.
+ }
+
+ //level must be between 0 and 1.0
+ if (info.level > 1) {
+ info.level = (info.level / 100);
+ }
+
+ if (!info.hasOwnProperty('charging')) {
+ info.charging = info.isPlugged;
+ }
+
+ if (batteryManager._charging !== info.charging) {
+ batteryManager._charging = info.charging;
+ batteryManager.dispatchEvent('chargingchange');
+ }
+
+ //not all device provide chargingTime or discharging time
+ if (info.hasOwnProperty('chargingTime') && (batteryManager._chargingTime !== info.chargingTime)) {
+ batteryManager._chargingTime = info.chargingTime;
+ batteryManager.dispatchEvent('chargingtimechange');
+ }
+
+ if (info.hasOwnProperty('dischargingTime') && (batteryManager._dischargingTime !== info.dischargingTime)) {
+ batteryManager._dischargingTime = info.dischargingTime;
+ batteryManager.dispatchEvent('dischargingtimechange');
+ }
+
+ if (batteryManager._level !== info.level) {
+ batteryManager._level = info.level;
+ batteryManager.dispatchEvent('levelchange');
+ }
+ }
+};
+
+
+/**
+ * Error callback for battery start
+ */
+BatteryManager.prototype._error = function (e) {
+ console.log('Error initializing Battery: ' + e);
+};
+
+// EventTarget Interface
+/**
+ * Adds an event listener to the target.
+ * @param {string} type The name of the event.
+ * @param {handler} The handler for the event. This is
+ * called when the event is dispatched.
+ */
+BatteryManager.prototype.addEventListener = function (type, handler) {
+ var e = type.toLowerCase();
+ //if the type is a channel(EventHandler)
+ if ((targetEventHandlers[e] !== 'undefined')) {
+ targetEventHandlers[e].subscribe(handler);
+ } else {
+ console.log('Error with channel');
+ }
+};
+
+/**
+ * Removes an event listener from the target.
+ * @param {string} type The name of the event.
+ * @param {EventListenerType} handler The handler for the event.
+ */
+BatteryManager.prototype.removeEventListener = function (type, handler) {
+ var e = type.toLowerCase();
+ if (typeof targetEventHandlers[e] !== 'undefined') {
+ targetEventHandlers[e].unsubscribe(handler);
+ } else {
+ console.log('Error with channel in removeListener');
+ }
+};
+
+function createEvent(type, data) {
+ var event = document.createEvent('Events');
+ event.initEvent(type, false, false);
+ if (data) {
+ for (var i in data) {
+ if (data.hasOwnProperty(i)) {
+ event[i] = data[i];
+ }
+ }
+ }
+ return event;
+}
+
+/**
+ * Dispatches an event and calls all the listeners that are listening to
+ * the type of the event.
+ * @param {!Event} event The event to dispatch.
+ */
+BatteryManager.prototype.dispatchEvent = function (type) {
+ var e = type.toLowerCase(),
+ evt = createEvent(e,null);
+ if (typeof targetEventHandlers[e] !== 'undefined') {
+ setTimeout(function () {
+ targetEventHandlers[e].fire(evt);
+ }, 0);
+ } else {
+ console.log('Error with channel in dispatchEvent');
+ }
+};
+
+function getBattery() {
+ var existingBatteryManager = cordova.require('cordova/modulemapper').getOriginalSymbol(window, 'navigator.getBattery');
+ //Promise detection
+ if (typeof Promise !== 'undefined') {
+ //if implementation use promise (warning with firefoxos)
+ if (typeof existingBatteryManager === 'function' && existingBatteryManager().then === 'function') {
+ return existingBatteryManager();
+ }
+ return new Promise(
+ function (resolve, reject) {
+ resolve(batteryManager);
+ }
+ );
+ } else {
+ console.log('Promise not supported');
+ }
+}
+
+module.exports = getBattery;
\ No newline at end of file