mirror of
https://code.equilibrium.co.ao/ITO/doneit-web.git
synced 2026-04-19 13:02:56 +00:00
save
This commit is contained in:
tiago.kayaya
+159
@@ -0,0 +1,159 @@
|
||||
/*
|
||||
*
|
||||
* 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.
|
||||
*
|
||||
*/
|
||||
|
||||
/**
|
||||
* Creates the exec bridge used to notify the native code of
|
||||
* commands.
|
||||
*/
|
||||
var cordova = require('cordova');
|
||||
var utils = require('cordova/utils');
|
||||
var base64 = require('cordova/base64');
|
||||
|
||||
function massageArgsJsToNative (args) {
|
||||
if (!args || utils.typeName(args) !== 'Array') {
|
||||
return args;
|
||||
}
|
||||
var ret = [];
|
||||
args.forEach(function (arg, i) {
|
||||
if (utils.typeName(arg) === 'ArrayBuffer') {
|
||||
ret.push({
|
||||
CDVType: 'ArrayBuffer',
|
||||
data: base64.fromArrayBuffer(arg)
|
||||
});
|
||||
} else {
|
||||
ret.push(arg);
|
||||
}
|
||||
});
|
||||
return ret;
|
||||
}
|
||||
|
||||
function massageMessageNativeToJs (message) {
|
||||
if (message.CDVType === 'ArrayBuffer') {
|
||||
var stringToArrayBuffer = function (str) {
|
||||
var ret = new Uint8Array(str.length);
|
||||
for (var i = 0; i < str.length; i++) {
|
||||
ret[i] = str.charCodeAt(i);
|
||||
}
|
||||
return ret.buffer;
|
||||
};
|
||||
var base64ToArrayBuffer = function (b64) {
|
||||
return stringToArrayBuffer(atob(b64)); // eslint-disable-line no-undef
|
||||
};
|
||||
message = base64ToArrayBuffer(message.data);
|
||||
}
|
||||
return message;
|
||||
}
|
||||
|
||||
function convertMessageToArgsNativeToJs (message) {
|
||||
var args = [];
|
||||
if (!message || !Object.prototype.hasOwnProperty.call(message, 'CDVType')) {
|
||||
args.push(message);
|
||||
} else if (message.CDVType === 'MultiPart') {
|
||||
message.messages.forEach(function (e) {
|
||||
args.push(massageMessageNativeToJs(e));
|
||||
});
|
||||
} else {
|
||||
args.push(massageMessageNativeToJs(message));
|
||||
}
|
||||
return args;
|
||||
}
|
||||
|
||||
var iOSExec = function () {
|
||||
var successCallback, failCallback, service, action, actionArgs;
|
||||
var callbackId = null;
|
||||
if (typeof arguments[0] !== 'string') {
|
||||
// FORMAT ONE
|
||||
successCallback = arguments[0];
|
||||
failCallback = arguments[1];
|
||||
service = arguments[2];
|
||||
action = arguments[3];
|
||||
actionArgs = arguments[4];
|
||||
|
||||
// Since we need to maintain backwards compatibility, we have to pass
|
||||
// an invalid callbackId even if no callback was provided since plugins
|
||||
// will be expecting it. The Cordova.exec() implementation allocates
|
||||
// an invalid callbackId and passes it even if no callbacks were given.
|
||||
callbackId = 'INVALID';
|
||||
} else {
|
||||
throw new Error('The old format of this exec call has been removed (deprecated since 2.1). Change to: ' + // eslint-disable-line
|
||||
'cordova.exec(null, null, \'Service\', \'action\', [ arg1, arg2 ]);');
|
||||
}
|
||||
|
||||
// If actionArgs is not provided, default to an empty array
|
||||
actionArgs = actionArgs || [];
|
||||
|
||||
// Register the callbacks and add the callbackId to the positional
|
||||
// arguments if given.
|
||||
if (successCallback || failCallback) {
|
||||
callbackId = service + cordova.callbackId++;
|
||||
cordova.callbacks[callbackId] =
|
||||
{ success: successCallback, fail: failCallback };
|
||||
}
|
||||
|
||||
actionArgs = massageArgsJsToNative(actionArgs);
|
||||
|
||||
// CB-10133 DataClone DOM Exception 25 guard (fast function remover)
|
||||
var command = [callbackId, service, action, JSON.parse(JSON.stringify(actionArgs))];
|
||||
window.webkit.messageHandlers.cordova.postMessage(command);
|
||||
};
|
||||
|
||||
iOSExec.nativeCallback = function (callbackId, status, message, keepCallback, debug) {
|
||||
var success = status === 0 || status === 1;
|
||||
var args = convertMessageToArgsNativeToJs(message);
|
||||
Promise.resolve().then(function () {
|
||||
cordova.callbackFromNative(callbackId, success, status, args, keepCallback); // eslint-disable-line
|
||||
});
|
||||
};
|
||||
|
||||
// for backwards compatibility
|
||||
iOSExec.nativeEvalAndFetch = function (func) {
|
||||
try {
|
||||
func();
|
||||
} catch (e) {
|
||||
console.log(e);
|
||||
}
|
||||
};
|
||||
|
||||
// Proxy the exec for bridge changes. See CB-10106
|
||||
|
||||
function cordovaExec () {
|
||||
var cexec = require('cordova/exec');
|
||||
var cexec_valid = (typeof cexec.nativeFetchMessages === 'function') && (typeof cexec.nativeEvalAndFetch === 'function') && (typeof cexec.nativeCallback === 'function');
|
||||
return (cexec_valid && execProxy !== cexec) ? cexec : iOSExec;
|
||||
}
|
||||
|
||||
function execProxy () {
|
||||
cordovaExec().apply(null, arguments);
|
||||
}
|
||||
|
||||
execProxy.nativeFetchMessages = function () {
|
||||
return cordovaExec().nativeFetchMessages.apply(null, arguments);
|
||||
};
|
||||
|
||||
execProxy.nativeEvalAndFetch = function () {
|
||||
return cordovaExec().nativeEvalAndFetch.apply(null, arguments);
|
||||
};
|
||||
|
||||
execProxy.nativeCallback = function () {
|
||||
return cordovaExec().nativeCallback.apply(null, arguments);
|
||||
};
|
||||
|
||||
module.exports = execProxy;
|
||||
+39
@@ -0,0 +1,39 @@
|
||||
/*
|
||||
*
|
||||
* 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.
|
||||
*
|
||||
*/
|
||||
|
||||
module.exports = {
|
||||
id: 'ios',
|
||||
bootstrap: function () {
|
||||
// Attach the console polyfill that is iOS-only to window.console
|
||||
// see the file under plugin/ios/console.js
|
||||
require('cordova/modulemapper').clobbers('cordova/plugin/ios/console', 'window.console');
|
||||
|
||||
// Attach the wkwebkit utility to window.WkWebView
|
||||
// see the file under plugin/ios/wkwebkit.js
|
||||
require('cordova/modulemapper').clobbers('cordova/plugin/ios/wkwebkit', 'window.WkWebView');
|
||||
|
||||
// Attach the splashscreen utility to window.navigator.splashscreen
|
||||
// see the file under plugin/ios/launchscreen.js
|
||||
require('cordova/modulemapper').clobbers('cordova/plugin/ios/launchscreen', 'navigator.splashscreen');
|
||||
|
||||
require('cordova/channel').onNativeReady.fire();
|
||||
}
|
||||
};
|
||||
@@ -0,0 +1,186 @@
|
||||
/*
|
||||
*
|
||||
* 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 logger = require('cordova/plugin/ios/logger');
|
||||
|
||||
// ------------------------------------------------------------------------------
|
||||
// object that we're exporting
|
||||
// ------------------------------------------------------------------------------
|
||||
var console = module.exports;
|
||||
|
||||
// ------------------------------------------------------------------------------
|
||||
// copy of the original console object
|
||||
// ------------------------------------------------------------------------------
|
||||
var WinConsole = window.console;
|
||||
|
||||
// ------------------------------------------------------------------------------
|
||||
// whether to use the logger
|
||||
// ------------------------------------------------------------------------------
|
||||
var UseLogger = false;
|
||||
|
||||
// ------------------------------------------------------------------------------
|
||||
// Timers
|
||||
// ------------------------------------------------------------------------------
|
||||
var Timers = {};
|
||||
|
||||
// ------------------------------------------------------------------------------
|
||||
// used for unimplemented methods
|
||||
// ------------------------------------------------------------------------------
|
||||
function noop () {}
|
||||
|
||||
// ------------------------------------------------------------------------------
|
||||
// used for unimplemented methods
|
||||
// ------------------------------------------------------------------------------
|
||||
console.useLogger = function (value) {
|
||||
if (arguments.length) UseLogger = !!value;
|
||||
|
||||
if (UseLogger) {
|
||||
if (logger.useConsole()) {
|
||||
throw new Error('console and logger are too intertwingly');
|
||||
}
|
||||
}
|
||||
|
||||
return UseLogger;
|
||||
};
|
||||
|
||||
// ------------------------------------------------------------------------------
|
||||
console.log = function () {
|
||||
if (logger.useConsole()) return;
|
||||
logger.log.apply(logger, [].slice.call(arguments));
|
||||
};
|
||||
|
||||
// ------------------------------------------------------------------------------
|
||||
console.error = function () {
|
||||
if (logger.useConsole()) return;
|
||||
logger.error.apply(logger, [].slice.call(arguments));
|
||||
};
|
||||
|
||||
// ------------------------------------------------------------------------------
|
||||
console.warn = function () {
|
||||
if (logger.useConsole()) return;
|
||||
logger.warn.apply(logger, [].slice.call(arguments));
|
||||
};
|
||||
|
||||
// ------------------------------------------------------------------------------
|
||||
console.info = function () {
|
||||
if (logger.useConsole()) return;
|
||||
logger.info.apply(logger, [].slice.call(arguments));
|
||||
};
|
||||
|
||||
// ------------------------------------------------------------------------------
|
||||
console.debug = function () {
|
||||
if (logger.useConsole()) return;
|
||||
logger.debug.apply(logger, [].slice.call(arguments));
|
||||
};
|
||||
|
||||
// ------------------------------------------------------------------------------
|
||||
console.assert = function (expression) {
|
||||
if (expression) return;
|
||||
|
||||
var message = logger.format.apply(logger.format, [].slice.call(arguments, 1));
|
||||
console.log('ASSERT: ' + message);
|
||||
};
|
||||
|
||||
// ------------------------------------------------------------------------------
|
||||
console.clear = function () {};
|
||||
|
||||
// ------------------------------------------------------------------------------
|
||||
console.dir = function (object) {
|
||||
console.log('%o', object);
|
||||
};
|
||||
|
||||
// ------------------------------------------------------------------------------
|
||||
console.dirxml = function (node) {
|
||||
console.log(node.innerHTML);
|
||||
};
|
||||
|
||||
// ------------------------------------------------------------------------------
|
||||
console.trace = noop;
|
||||
|
||||
// ------------------------------------------------------------------------------
|
||||
console.group = console.log;
|
||||
|
||||
// ------------------------------------------------------------------------------
|
||||
console.groupCollapsed = console.log;
|
||||
|
||||
// ------------------------------------------------------------------------------
|
||||
console.groupEnd = noop;
|
||||
|
||||
// ------------------------------------------------------------------------------
|
||||
console.time = function (name) {
|
||||
Timers[name] = new Date().valueOf();
|
||||
};
|
||||
|
||||
// ------------------------------------------------------------------------------
|
||||
console.timeEnd = function (name) {
|
||||
var timeStart = Timers[name];
|
||||
if (!timeStart) {
|
||||
console.warn('unknown timer: ' + name);
|
||||
return;
|
||||
}
|
||||
|
||||
var timeElapsed = new Date().valueOf() - timeStart;
|
||||
console.log(name + ': ' + timeElapsed + 'ms');
|
||||
};
|
||||
|
||||
// ------------------------------------------------------------------------------
|
||||
console.timeStamp = noop;
|
||||
|
||||
// ------------------------------------------------------------------------------
|
||||
console.profile = noop;
|
||||
|
||||
// ------------------------------------------------------------------------------
|
||||
console.profileEnd = noop;
|
||||
|
||||
// ------------------------------------------------------------------------------
|
||||
console.count = noop;
|
||||
|
||||
// ------------------------------------------------------------------------------
|
||||
console.exception = console.log;
|
||||
|
||||
// ------------------------------------------------------------------------------
|
||||
console.table = function (data, columns) {
|
||||
console.log('%o', data);
|
||||
};
|
||||
|
||||
// ------------------------------------------------------------------------------
|
||||
// return a new function that calls both functions passed as args
|
||||
// ------------------------------------------------------------------------------
|
||||
function wrappedOrigCall (orgFunc, newFunc) {
|
||||
return function () {
|
||||
var args = [].slice.call(arguments);
|
||||
try { orgFunc.apply(WinConsole, args); } catch (e) {}
|
||||
try { newFunc.apply(console, args); } catch (e) {}
|
||||
};
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------
|
||||
// For every function that exists in the original console object, that
|
||||
// also exists in the new console object, wrap the new console method
|
||||
// with one that calls both
|
||||
// ------------------------------------------------------------------------------
|
||||
for (var key in console) {
|
||||
if (typeof WinConsole[key] === 'function') {
|
||||
console[key] = wrappedOrigCall(WinConsole[key], console[key]);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,33 @@
|
||||
/*
|
||||
*
|
||||
* 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');
|
||||
|
||||
var launchscreen = {
|
||||
show: function () {
|
||||
exec(null, null, 'LaunchScreen', 'show', []);
|
||||
},
|
||||
hide: function () {
|
||||
exec(null, null, 'LaunchScreen', 'hide', []);
|
||||
}
|
||||
};
|
||||
|
||||
module.exports = launchscreen;
|
||||
@@ -0,0 +1,348 @@
|
||||
/*
|
||||
*
|
||||
* 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.
|
||||
*
|
||||
*/
|
||||
|
||||
// ------------------------------------------------------------------------------
|
||||
// The logger module exports the following properties/functions:
|
||||
//
|
||||
// LOG - constant for the level LOG
|
||||
// ERROR - constant for the level ERROR
|
||||
// WARN - constant for the level WARN
|
||||
// INFO - constant for the level INFO
|
||||
// DEBUG - constant for the level DEBUG
|
||||
// logLevel() - returns current log level
|
||||
// logLevel(value) - sets and returns a new log level
|
||||
// useConsole() - returns whether logger is using console
|
||||
// useConsole(value) - sets and returns whether logger is using console
|
||||
// log(message,...) - logs a message at level LOG
|
||||
// error(message,...) - logs a message at level ERROR
|
||||
// warn(message,...) - logs a message at level WARN
|
||||
// info(message,...) - logs a message at level INFO
|
||||
// debug(message,...) - logs a message at level DEBUG
|
||||
// logLevel(level,message,...) - logs a message specified level
|
||||
//
|
||||
// ------------------------------------------------------------------------------
|
||||
|
||||
var logger = exports;
|
||||
|
||||
var exec = require('cordova/exec');
|
||||
|
||||
var UseConsole = false;
|
||||
var UseLogger = true;
|
||||
var Queued = [];
|
||||
var DeviceReady = false;
|
||||
var CurrentLevel;
|
||||
|
||||
var originalConsole = console;
|
||||
|
||||
/**
|
||||
* Logging levels
|
||||
*/
|
||||
|
||||
var Levels = [
|
||||
'LOG',
|
||||
'ERROR',
|
||||
'WARN',
|
||||
'INFO',
|
||||
'DEBUG'
|
||||
];
|
||||
|
||||
/*
|
||||
* add the logging levels to the logger object and
|
||||
* to a separate levelsMap object for testing
|
||||
*/
|
||||
|
||||
var LevelsMap = {};
|
||||
for (var i = 0; i < Levels.length; i++) {
|
||||
var level = Levels[i];
|
||||
LevelsMap[level] = i;
|
||||
logger[level] = level;
|
||||
}
|
||||
|
||||
CurrentLevel = LevelsMap.WARN;
|
||||
|
||||
/**
|
||||
* Getter/Setter for the logging level
|
||||
*
|
||||
* Returns the current logging level.
|
||||
*
|
||||
* When a value is passed, sets the logging level to that value.
|
||||
* The values should be one of the following constants:
|
||||
* logger.LOG
|
||||
* logger.ERROR
|
||||
* logger.WARN
|
||||
* logger.INFO
|
||||
* logger.DEBUG
|
||||
*
|
||||
* The value used determines which messages get printed. The logging
|
||||
* values above are in order, and only messages logged at the logging
|
||||
* level or above will actually be displayed to the user. E.g., the
|
||||
* default level is WARN, so only messages logged with LOG, ERROR, or
|
||||
* WARN will be displayed; INFO and DEBUG messages will be ignored.
|
||||
*/
|
||||
logger.level = function (value) {
|
||||
if (arguments.length) {
|
||||
if (LevelsMap[value] === null) {
|
||||
throw new Error('invalid logging level: ' + value);
|
||||
}
|
||||
CurrentLevel = LevelsMap[value];
|
||||
}
|
||||
|
||||
return Levels[CurrentLevel];
|
||||
};
|
||||
|
||||
/**
|
||||
* Getter/Setter for the useConsole functionality
|
||||
*
|
||||
* When useConsole is true, the logger will log via the
|
||||
* browser 'console' object.
|
||||
*/
|
||||
logger.useConsole = function (value) {
|
||||
if (arguments.length) UseConsole = !!value;
|
||||
|
||||
if (UseConsole) {
|
||||
if (typeof console === 'undefined') {
|
||||
throw new Error('global console object is not defined');
|
||||
}
|
||||
|
||||
if (typeof console.log !== 'function') {
|
||||
throw new Error('global console object does not have a log function');
|
||||
}
|
||||
|
||||
if (typeof console.useLogger === 'function') {
|
||||
if (console.useLogger()) {
|
||||
throw new Error('console and logger are too intertwingly');
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return UseConsole;
|
||||
};
|
||||
|
||||
/**
|
||||
* Getter/Setter for the useLogger functionality
|
||||
*
|
||||
* When useLogger is true, the logger will log via the
|
||||
* native Logger plugin.
|
||||
*/
|
||||
logger.useLogger = function (value) {
|
||||
// Enforce boolean
|
||||
if (arguments.length) UseLogger = !!value;
|
||||
return UseLogger;
|
||||
};
|
||||
|
||||
/**
|
||||
* Logs a message at the LOG level.
|
||||
*
|
||||
* Parameters passed after message are used applied to
|
||||
* the message with utils.format()
|
||||
*/
|
||||
logger.log = function (message) { logWithArgs('LOG', arguments); };
|
||||
|
||||
/**
|
||||
* Logs a message at the ERROR level.
|
||||
*
|
||||
* Parameters passed after message are used applied to
|
||||
* the message with utils.format()
|
||||
*/
|
||||
logger.error = function (message) { logWithArgs('ERROR', arguments); };
|
||||
|
||||
/**
|
||||
* Logs a message at the WARN level.
|
||||
*
|
||||
* Parameters passed after message are used applied to
|
||||
* the message with utils.format()
|
||||
*/
|
||||
logger.warn = function (message) { logWithArgs('WARN', arguments); };
|
||||
|
||||
/**
|
||||
* Logs a message at the INFO level.
|
||||
*
|
||||
* Parameters passed after message are used applied to
|
||||
* the message with utils.format()
|
||||
*/
|
||||
logger.info = function (message) { logWithArgs('INFO', arguments); };
|
||||
|
||||
/**
|
||||
* Logs a message at the DEBUG level.
|
||||
*
|
||||
* Parameters passed after message are used applied to
|
||||
* the message with utils.format()
|
||||
*/
|
||||
logger.debug = function (message) { logWithArgs('DEBUG', arguments); };
|
||||
|
||||
// log at the specified level with args
|
||||
function logWithArgs (level, args) {
|
||||
args = [level].concat([].slice.call(args));
|
||||
logger.logLevel.apply(logger, args);
|
||||
}
|
||||
|
||||
// return the correct formatString for an object
|
||||
function formatStringForMessage (message) {
|
||||
return (typeof message === 'string') ? '' : '%o';
|
||||
}
|
||||
|
||||
/**
|
||||
* Logs a message at the specified level.
|
||||
*
|
||||
* Parameters passed after message are used applied to
|
||||
* the message with utils.format()
|
||||
*/
|
||||
logger.logLevel = function (level /* , ... */) {
|
||||
// format the message with the parameters
|
||||
var formatArgs = [].slice.call(arguments, 1);
|
||||
var fmtString = formatStringForMessage(formatArgs[0]);
|
||||
if (fmtString.length > 0) {
|
||||
formatArgs.unshift(fmtString); // add formatString
|
||||
}
|
||||
|
||||
var message = logger.format.apply(logger.format, formatArgs);
|
||||
|
||||
if (LevelsMap[level] === null) {
|
||||
throw new Error('invalid logging level: ' + level);
|
||||
}
|
||||
|
||||
if (LevelsMap[level] > CurrentLevel) return;
|
||||
|
||||
// queue the message if not yet at deviceready
|
||||
if (!DeviceReady && !UseConsole) {
|
||||
Queued.push([level, message]);
|
||||
return;
|
||||
}
|
||||
|
||||
// Log using the native logger if that is enabled
|
||||
if (UseLogger) {
|
||||
exec(null, null, 'Console', 'logLevel', [level, message]);
|
||||
}
|
||||
|
||||
// Log using the console if that is enabled
|
||||
if (UseConsole) {
|
||||
// make sure console is not using logger
|
||||
if (console.useLogger()) {
|
||||
throw new Error('console and logger are too intertwingly');
|
||||
}
|
||||
|
||||
// log to the console
|
||||
switch (level) {
|
||||
case logger.LOG: originalConsole.log(message); break;
|
||||
case logger.ERROR: originalConsole.log('ERROR: ' + message); break;
|
||||
case logger.WARN: originalConsole.log('WARN: ' + message); break;
|
||||
case logger.INFO: originalConsole.log('INFO: ' + message); break;
|
||||
case logger.DEBUG: originalConsole.log('DEBUG: ' + message); break;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Formats a string and arguments following it ala console.log()
|
||||
*
|
||||
* Any remaining arguments will be appended to the formatted string.
|
||||
*
|
||||
* for rationale, see FireBug's Console API:
|
||||
* http://getfirebug.com/wiki/index.php/Console_API
|
||||
*/
|
||||
logger.format = function (formatString, args) {
|
||||
return __format(arguments[0], [].slice.call(arguments, 1)).join(' ');
|
||||
};
|
||||
|
||||
// ------------------------------------------------------------------------------
|
||||
/**
|
||||
* Formats a string and arguments following it ala vsprintf()
|
||||
*
|
||||
* format chars:
|
||||
* %j - format arg as JSON
|
||||
* %o - format arg as JSON
|
||||
* %c - format arg as ''
|
||||
* %% - replace with '%'
|
||||
* any other char following % will format it's
|
||||
* arg via toString().
|
||||
*
|
||||
* Returns an array containing the formatted string and any remaining
|
||||
* arguments.
|
||||
*/
|
||||
function __format (formatString, args) {
|
||||
if (formatString === null || formatString === undefined) return [''];
|
||||
if (arguments.length === 1) return [formatString.toString()];
|
||||
|
||||
if (typeof formatString !== 'string') { formatString = formatString.toString(); }
|
||||
|
||||
var pattern = /(.*?)%(.)(.*)/;
|
||||
var rest = formatString;
|
||||
var result = [];
|
||||
|
||||
while (args.length) {
|
||||
var match = pattern.exec(rest);
|
||||
if (!match) break;
|
||||
|
||||
var arg = args.shift();
|
||||
rest = match[3];
|
||||
result.push(match[1]);
|
||||
|
||||
if (match[2] === '%') {
|
||||
result.push('%');
|
||||
args.unshift(arg);
|
||||
continue;
|
||||
}
|
||||
|
||||
result.push(__formatted(arg, match[2]));
|
||||
}
|
||||
|
||||
result.push(rest);
|
||||
|
||||
var remainingArgs = [].slice.call(args);
|
||||
remainingArgs.unshift(result.join(''));
|
||||
return remainingArgs;
|
||||
}
|
||||
|
||||
function __formatted (object, formatChar) {
|
||||
try {
|
||||
switch (formatChar) {
|
||||
case 'j':
|
||||
case 'o': return JSON.stringify(object);
|
||||
case 'c': return '';
|
||||
}
|
||||
} catch (e) {
|
||||
return 'error JSON.stringify()ing argument: ' + e;
|
||||
}
|
||||
|
||||
if ((object === null) || (object === undefined)) {
|
||||
return Object.prototype.toString.call(object);
|
||||
}
|
||||
|
||||
return object.toString();
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------
|
||||
// when deviceready fires, log queued messages
|
||||
logger.__onDeviceReady = function () {
|
||||
if (DeviceReady) return;
|
||||
|
||||
DeviceReady = true;
|
||||
|
||||
for (var i = 0; i < Queued.length; i++) {
|
||||
var messageArgs = Queued[i];
|
||||
logger.logLevel(messageArgs[0], messageArgs[1]);
|
||||
}
|
||||
|
||||
Queued = null;
|
||||
};
|
||||
|
||||
// add a deviceready event to log queued messages
|
||||
document.addEventListener('deviceready', logger.__onDeviceReady, false);
|
||||
@@ -0,0 +1,42 @@
|
||||
/*
|
||||
*
|
||||
* 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');
|
||||
|
||||
var WkWebKit = {
|
||||
allowsBackForwardNavigationGestures: function (allow) {
|
||||
exec(null, null, 'CDVWebViewEngine', 'allowsBackForwardNavigationGestures', [allow]);
|
||||
},
|
||||
convertFilePath: function (path) {
|
||||
if (!path || !window.CDV_ASSETS_URL) {
|
||||
return path;
|
||||
}
|
||||
if (path.startsWith('/')) {
|
||||
return window.CDV_ASSETS_URL + '/_app_file_' + path;
|
||||
}
|
||||
if (path.startsWith('file://')) {
|
||||
return window.CDV_ASSETS_URL + path.replace('file://', '/_app_file_');
|
||||
}
|
||||
return path;
|
||||
}
|
||||
};
|
||||
|
||||
module.exports = WkWebKit;
|
||||
Reference in New Issue
Block a user