var types_ = validator_.Types;
var T_ = xwalk.utils.type;
var native_ = new xwalk.utils.NativeManager(extension);
+var privUtils_ = xwalk.utils;
function InternalValues_(data) {
break;
default:
- console.log('Unknown event: ' + event.action);
+ privUtils_.log('Unknown event: ' + event.action);
break;
}
var T = xwalk.utils.type;
var Converter = xwalk.utils.converter;
var AV = xwalk.utils.validator;
+var privUtils_ = xwalk.utils;
var native = new xwalk.utils.NativeManager(extension);
};
function makeDateConst(obj) {
- console.log('Enter MakeConst');
+ privUtils_.log('Enter MakeConst');
obj.setDate = function() {};
obj.setFullYear = function() {};
obj.setHours = function() {};
obj.setUTCMonth = function() {};
obj.setUTCSeconds = function() {};
obj.setYear = function() {};
- console.log('Leave MakeConst');
+ privUtils_.log('Leave MakeConst');
}
//class AlarmAbsolute //////////////////////////////////////////////////
var T = xwalk.utils.type;
var Converter = xwalk.utils.converter;
var AV = xwalk.utils.validator;
+var privUtils_ = xwalk.utils;
var native = new xwalk.utils.NativeManager(extension);
break;
default:
- console.logd('Unknown mode: ' + msg.action);
+ privUtils_.log('Unknown mode: ' + msg.action);
return;
}
};
ListenerManager.prototype.addListener = function(callback) {
- console.log('ListenerManager.prototype.addListener');
+ privUtils_.log('ListenerManager.prototype.addListener');
var id = this.nextId;
if (!this.nativeSet) {
this.native.addListener(this.listenerName, this.onListenerCalled.bind(this));
var parsedName = eventName.split('.');
var eventInfo = {};
if (parsedName.length < 3) {
- console.logd('Invalid event name returned' + eventName);
+ privUtils_.log('Invalid event name returned' + eventName);
}
for (var id in event_listeners_[eventName]) {
if (event_listeners_[eventName].hasOwnProperty(id)) {
var validator_ = xwalk.utils.validator;
var types_ = validator_.Types;
var native_ = new xwalk.utils.NativeManager(extension);
+var privUtils_ = xwalk.utils;
function CommonFS() {};
};
}
} catch(e) {
- console.log("Exception while getting widget paths was thrown: " + e);
+ privUtils_.log("Exception while getting widget paths was thrown: " + e);
}
}
} else {
_fileRealPath = aPath;
}
- console.log("REAL PATH:" + _fileRealPath);
+ privUtils_.log("REAL PATH:" + _fileRealPath);
if (_fileRealPath === "undefined" || _fileRealPath === "null") {
throw new WebAPIException(WebAPIException.TYPE_MISMATCH_ERR);
}
* }
*
* m.name = 'A brand new name';
- * console.log(m.name); // Name
+ * privUtils_.log(m.name); // Name
*/
function propertyFactory_(that, name, value, flags, options) {
flags = flags || 0;
};
var BluetoothClass_hasService = function() {
- console.log('Entered BluetoothClass.hasService()');
+ privUtils_.log('Entered BluetoothClass.hasService()');
privUtils_.checkPrivilegeAccess4Ver("2.4", Privilege.BLUETOOTH, Privilege.BLUETOOTH_GAP);
var args = AV.validateMethod(arguments, [
callback();
}
} else {
- console.log('Received event for an unknown socket: ' + event.id);
+ privUtils_.log('Received event for an unknown socket: ' + event.id);
}
};
}
};
BluetoothSocket.prototype.writeData = function() {
- console.log('Entered BluetoothSocket.writeData()');
+ privUtils_.log('Entered BluetoothSocket.writeData()');
var args = AV.validateMethod(arguments, [
{
};
BluetoothSocket.prototype.readData = function() {
- console.log('Entered BluetoothSocket.readData()');
+ privUtils_.log('Entered BluetoothSocket.readData()');
var callArgs = {
id : this._id
};
BluetoothSocket.prototype.close = function() {
- console.log('Entered BluetoothSocket.close()');
+ privUtils_.log('Entered BluetoothSocket.close()');
if (_BLUETOOTH_SOCKET_STATE_CLOSED !== this.state) {
var callArgs = {
};
BluetoothLEDevice.prototype.connect = function() {
- console.log('Entered BluetoothLEDevice.connect()');
+ privUtils_.log('Entered BluetoothLEDevice.connect()');
var args = AV.validateMethod(arguments, [
{
name : 'successCallback',
};
BluetoothLEDevice.prototype.disconnect = function() {
- console.log('Entered BluetoothLEDevice.disconnect()');
+ privUtils_.log('Entered BluetoothLEDevice.disconnect()');
var args = AV.validateMethod(arguments, [
{
name : 'successCallback',
};
BluetoothLEDevice.prototype.getService = function() {
- console.log('Entered BluetoothLEDevice.getService()');
+ privUtils_.log('Entered BluetoothLEDevice.getService()');
var args = AV.validateMethod(arguments, [
{
name: 'uuid',
};
BluetoothLEDevice.prototype.getServiceAllUuids = function() {
- console.log('Entered BluetoothLEDevice.getServiceAllUuids()');
+ privUtils_.log('Entered BluetoothLEDevice.getServiceAllUuids()');
var callArgs = {
address : this.address
};
BluetoothLEDevice.prototype.addConnectStateChangeListener = function() {
- console.log('Entered BluetoothLEDevice.addConnectStateChangeListener()');
+ privUtils_.log('Entered BluetoothLEDevice.addConnectStateChangeListener()');
var args = AV.validateMethod(arguments, [
{
name: 'listener',
};
BluetoothLEDevice.prototype.removeConnectStateChangeListener = function() {
- console.log('Entered BluetoothLEDevice.removeConnectStateChangeListener()');
+ privUtils_.log('Entered BluetoothLEDevice.removeConnectStateChangeListener()');
var args = AV.validateMethod(arguments, [
{
};
BluetoothDevice.prototype.connectToServiceByUUID = function() {
- console.log('Entered BluetoothDevice.connectToServiceByUUID()');
+ privUtils_.log('Entered BluetoothDevice.connectToServiceByUUID()');
var args = AV.validateMethod(arguments, [
{
var result = new BluetoothSocket(e);
if (service) {
- console.log(service);
+ privUtils_.log(service);
service.onconnect(result);
}
};
};
BluetoothServiceHandler.prototype.unregister = function() {
- console.log('Entered BluetoothServiceHandler.unregister()');
+ privUtils_.log('Entered BluetoothServiceHandler.unregister()');
var args = AV.validateMethod(arguments, [
{
name : 'successCallback',
break;
default:
- console.log('Unknown event: ' + event.event);
+ privUtils_.log('Unknown event: ' + event.event);
break;
}
callback(param);
}
} else {
- console.log('Received event for an unknown application: ' + event.id);
+ privUtils_.log('Received event for an unknown application: ' + event.id);
}
};
}
};
BluetoothHealthApplication.prototype.unregister = function() {
- console.log('Entered BluetoothHealthApplication.unregister()');
+ privUtils_.log('Entered BluetoothHealthApplication.unregister()');
var args = AV.validateMethod(arguments, [
{
name : 'successCallback',
BluetoothHealthProfileHandler.prototype.constructor = BluetoothProfileHandler;
BluetoothHealthProfileHandler.prototype.registerSinkApplication = function() {
- console.log('Entered BluetoothHealthProfileHandler.registerSinkApplication()');
+ privUtils_.log('Entered BluetoothHealthProfileHandler.registerSinkApplication()');
var args = AV.validateMethod(arguments, [
{
};
BluetoothHealthProfileHandler.prototype.connectToSource = function() {
- console.log('Entered BluetoothHealthProfileHandler.connectToSource()');
+ privUtils_.log('Entered BluetoothHealthProfileHandler.connectToSource()');
var args = AV.validateMethod(arguments, [
{
};
BluetoothHealthChannel.prototype.close = function() {
- console.log('Entered BluetoothHealthChannel.close()');
+ privUtils_.log('Entered BluetoothHealthChannel.close()');
if (this.isConnected) {
var callArgs = {
};
BluetoothHealthChannel.prototype.sendData = function() {
- console.log('Entered BluetoothHealthChannel.sendData()');
+ privUtils_.log('Entered BluetoothHealthChannel.sendData()');
var args = AV.validateMethod(arguments, [
{
name : 'data',
break;
default:
- console.log('Unknown mode: ' + e.event);
+ privUtils_.log('Unknown mode: ' + e.event);
return;
}
}
var BluetoothHealthChannel_setListener = function() {
- console.log('Entered BluetoothHealthChannel.setListener()');
+ privUtils_.log('Entered BluetoothHealthChannel.setListener()');
privUtils_.checkPrivilegeAccess4Ver("2.4", Privilege.BLUETOOTH, Privilege.BLUETOOTH_HEALTH);
var args = AV.validateMethod(arguments, [
{
};
var BluetoothHealthChannel_unsetListener = function() {
- console.log('Entered BluetoothHealthChannel.unsetListener ()');
+ privUtils_.log('Entered BluetoothHealthChannel.unsetListener ()');
if (T.isEmptyObject(_healthListeners)) {
privUtils_.checkPrivilegeAccess4Ver("2.4", Privilege.BLUETOOTH, Privilege.BLUETOOTH_HEALTH);
}
return ret;
default:
- console.log('Unknown mode: ' + event.action);
+ privUtils_.log('Unknown mode: ' + event.action);
return ret;
}
if (successCallback) {
return ret;
default:
- console.log('Unknown mode: ' + event.action);
+ privUtils_.log('Unknown mode: ' + event.action);
return ret;
}
});
};
BluetoothLEAdapter.prototype.startScan = function() {
- console.log('Entered BluetoothLEAdapter.startScan()');
+ privUtils_.log('Entered BluetoothLEAdapter.startScan()');
var args = AV.validateMethod(arguments, [{
name: 'successCallback',
type: AV.Types.FUNCTION
};
BluetoothLEAdapter.prototype.stopScan = function() {
- console.log('Entered BluetoothLEAdapter.stopScan()');
+ privUtils_.log('Entered BluetoothLEAdapter.stopScan()');
_bleScanListener.removeListener();
};
BluetoothLEAdapter.prototype.startAdvertise = function() {
- console.log('Entered BluetoothLEAdapter.startAdvertise()');
+ privUtils_.log('Entered BluetoothLEAdapter.startAdvertise()');
var args = AV.validateMethod(arguments, [{
name: 'advertiseData',
type: AV.Types.PLATFORM_OBJECT,
};
BluetoothLEAdapter.prototype.stopAdvertise = function() {
- console.log('Entered BluetoothLEAdapter.stopAdvertise()');
+ privUtils_.log('Entered BluetoothLEAdapter.stopAdvertise()');
var result = native.callSync('BluetoothLEAdapter_stopAdvertise', {});
});
this.readValue = function() {
- console.log('Entered BluetoothGATTCharacteristic.readValue()');
+ privUtils_.log('Entered BluetoothGATTCharacteristic.readValue()');
var args = AV.validateMethod(arguments, [{
name: 'successCallback',
type: AV.Types.FUNCTION
};
this.writeValue = function() {
- console.log('Entered BluetoothGATTCharacteristic.writeValue()');
+ privUtils_.log('Entered BluetoothGATTCharacteristic.writeValue()');
var args = AV.validateMethod(arguments, [{
name: 'value',
type: AV.Types.ARRAY,
};
var addValueChangeListener = function() {
- console.log('Entered BluetoothGATTCharacteristic.addValueChangeListener()');
+ privUtils_.log('Entered BluetoothGATTCharacteristic.addValueChangeListener()');
privUtils_.checkPrivilegeAccess4Ver("2.4", Privilege.BLUETOOTH, Privilege.BLUETOOTH_ADMIN);
var args = AV.validateMethod(arguments, [{
name: 'callback',
};
this.removeValueChangeListener = function() {
- console.log('Entered BluetoothGATTCharacteristic.removeValueChangeListener()');
+ privUtils_.log('Entered BluetoothGATTCharacteristic.removeValueChangeListener()');
var args = AV.validateMethod(arguments, [{
name: 'watchID',
var address_ = address;
this.readValue = function() {
- console.log('Entered BluetoothGATTDescriptor.readValue()');
+ privUtils_.log('Entered BluetoothGATTDescriptor.readValue()');
var args = AV.validateMethod(arguments, [{
name: 'successCallback',
type: AV.Types.FUNCTION
};
this.writeValue = function() {
- console.log('Entered BluetoothGATTDescriptor.writeValue()');
+ privUtils_.log('Entered BluetoothGATTDescriptor.writeValue()');
var args = AV.validateMethod(arguments, [{
name: 'value',
type: AV.Types.ARRAY,
};
BluetoothAdapter.prototype.setName = function() {
- console.log('Entered BluetoothAdapter.setName()');
+ privUtils_.log('Entered BluetoothAdapter.setName()');
var args = AV.validateMethod(arguments, [
{
name : 'name',
};
BluetoothAdapter.prototype.setPowered = function() {
- console.log('Entered BluetoothAdapter.setPowered()');
+ privUtils_.log('Entered BluetoothAdapter.setPowered()');
console.warn('DEPRECATION WARNING: setPowered() is deprecated and will be removed from next release. '
+ 'Let the user turn on/off Bluetooth through the Settings application instead.');
// This method is deprecated since Tizen 2.3 and will be removed in Tizen 3.0.
BluetoothAdapter.prototype.setVisible = function() {
- console.log('Entered BluetoothAdapter.setVisible()');
+ privUtils_.log('Entered BluetoothAdapter.setVisible()');
var args = AV.validateMethod(arguments, [
{
name : 'visible',
var _listener;
function _BluetoothAdapterChangeCallback(event) {
- console.log('_BluetoothAdapterChangeCallback');
+ privUtils_.log('_BluetoothAdapterChangeCallback');
var e = event;
var d;
break;
default:
- console.log('Unknown mode: ' + e.action);
+ privUtils_.log('Unknown mode: ' + e.action);
return;
}
}
BluetoothAdapter.prototype.setChangeListener = function() {
- console.log('Entered BluetoothAdapter.setChangeListener()');
+ privUtils_.log('Entered BluetoothAdapter.setChangeListener()');
var args = AV.validateMethod(arguments, [
{
name : 'changeCallback',
};
BluetoothAdapter.prototype.unsetChangeListener = function() {
- console.log('Entered BluetoothAdapter.unsetChangeListener()');
+ privUtils_.log('Entered BluetoothAdapter.unsetChangeListener()');
if (!T.isNullOrUndefined(_listener)) {
native.removeListener('BluetoothAdapterChangeCallback', _BluetoothAdapterChangeCallback);
_listener = undefined;
break;
default:
- console.log('Unknown mode: ' + e.action);
+ privUtils_.log('Unknown mode: ' + e.action);
return;
}
}
BluetoothAdapter.prototype.discoverDevices = function() {
- console.log('Entered BluetoothAdapter.discoverDevices()');
+ privUtils_.log('Entered BluetoothAdapter.discoverDevices()');
var args = AV.validateMethod(arguments, [
{
name : 'successCallback',
};
BluetoothAdapter.prototype.stopDiscovery = function() {
- console.log('Entered BluetoothAdapter.stopDiscovery()');
+ privUtils_.log('Entered BluetoothAdapter.stopDiscovery()');
var args = AV.validateMethod(arguments, [
{
name : 'successCallback',
};
BluetoothAdapter.prototype.getKnownDevices = function() {
- console.log('Entered BluetoothAdapter.getKnownDevices()');
+ privUtils_.log('Entered BluetoothAdapter.getKnownDevices()');
var args = AV.validateMethod(arguments, [
{
name : 'successCallback',
};
BluetoothAdapter.prototype.getDevice = function() {
- console.log('Entered BluetoothAdapter.getDevice()');
+ privUtils_.log('Entered BluetoothAdapter.getDevice()');
var args = AV.validateMethod(arguments, [
{
name : 'address',
};
BluetoothAdapter.prototype.createBonding = function() {
- console.log('Entered BluetoothAdapter.createBonding()');
+ privUtils_.log('Entered BluetoothAdapter.createBonding()');
var args = AV.validateMethod(arguments, [
{
name : 'address',
};
BluetoothAdapter.prototype.destroyBonding = function() {
- console.log('Entered BluetoothAdapter.destroyBonding()');
+ privUtils_.log('Entered BluetoothAdapter.destroyBonding()');
var args = AV.validateMethod(arguments, [
{
name : 'address',
};
BluetoothAdapter.prototype.registerRFCOMMServiceByUUID = function() {
- console.log('Entered BluetoothAdapter.registerRFCOMMServiceByUUID()');
+ privUtils_.log('Entered BluetoothAdapter.registerRFCOMMServiceByUUID()');
var args = AV.validateMethod(arguments, [
{
name : 'uuid',
};
BluetoothAdapter.prototype.getBluetoothProfileHandler = function() {
- console.log('Entered BluetoothAdapter.getBluetoothProfileHandler()');
+ privUtils_.log('Entered BluetoothAdapter.getBluetoothProfileHandler()');
var args = AV.validateMethod(arguments, [
{
BluetoothManager.prototype.getDefaultAdapter = function() {
- console.log('Entered BluetoothManager.getDefaultAdapter()');
+ privUtils_.log('Entered BluetoothManager.getDefaultAdapter()');
return BluetoothManager_getDefaultAdapter();
};
};
BluetoothManager.prototype.getLEAdapter = function() {
- console.log('Entered BluetoothManager.getLEAdapter()');
+ privUtils_.log('Entered BluetoothManager.getLEAdapter()');
return BluetoothManager_getLEAdapter();
};
// exports ///////////////////////////////////////////////////////////////////
break;
default:
- console.log('Unknown mode: ' + msg.action);
+ privUtils_.log('Unknown mode: ' + msg.action);
return;
}
// Convert email address from Contact object to string
var _contactEmailToString = function(obj) {
if (!type_.isArray(obj.emails) || obj.emails.length === 0) {
- console.log('Empty email list');
+ utils_.log('Empty email list');
return '';
}
var str = '';
for (var mail in obj.emails) {
if (!mail instanceof ContactEmailAddress || !type_.isArray(mail.types) ||
mail.types.length === 0) {
- console.log('Incorrect email type');
+ utils_.log('Incorrect email type');
continue;
}
str += 'EMAIL;';
var result = native_.callSync('ContentManager_getLyrics', data);
if (native_.isFailure(result)) {
- console.log('Getting lyrics failed for ' + data.contentURI);
+ utils_.log('Getting lyrics failed for ' + data.contentURI);
return;
}
convergenceDevices = [];
} else {
- console.log('UNKNOWN discovery state exception');
+ utils_.log('UNKNOWN discovery state exception');
}
}
});
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-
+
+var privUtils_ = xwalk.utils;
var validator_ = xwalk.utils.validator;
var types_ = validator_.Types;
var check_ = xwalk.utils.type;
var result = JSON.parse(json);
var callback = callbacks[result.callbackId];
- //console.log("PostMessage received: " + result.status);
+ //privUtils_.log("PostMessage received: " + result.status);
if (!callback) {
- console.logd('Ignoring unknown callback: ' + result.callbackId);
+ privUtils_.log('Ignoring unknown callback: ' + result.callbackId);
return;
}
setTimeout(function() {
});
listenerRegistered = true;
} catch (e) {
- console.log('Failed to register storage change listener, '
+ privUtils_.log('Failed to register storage change listener, '
+ 'storage information may be corrupted: ' + e.message);
}
}
function convertForEarlierVersionPath(aPath) {
if (isAppForEarlierVersion) {
if (aPath && aPath.indexOf(tizen24home) === 0) {
- console.log("Converting 2.4 style path to 3.0 pattern");
+ privUtils_.log("Converting 2.4 style path to 3.0 pattern");
aPath = homeDir + aPath.substr(tizen24home.length);
}
}
return null;
}
} catch (err) {
- console.log(err.name, err.message);
+ privUtils_.log(err.name, err.message);
return null;
}
}(data)),
};
}
- console.log("callbackInterval = " + callbackInterval + ", sampleInterval = " + sampleInterval);
+ utils_.log("callbackInterval = " + callbackInterval + ", sampleInterval = " + sampleInterval);
startListener(listenerId,
listener,
'HumanActivityMonitorManager_start',
var T = xwalk.utils.type;
var kIdKey = Symbol();
var converter = xwalk.utils.converter;
+var privUtils_ = xwalk.utils;
function createListener(name, c) {
var listenerName = name;
var callArgs = {};
callArgs.id = that[kIdKey];
if (!callArgs.id) {
- console.log("RemoteResource is not already stored in C++ layer, adding all members");
+ privUtils_.log("RemoteResource is not already stored in C++ layer, adding all members");
callArgs.hostAddress = that.hostAddress;
callArgs.connectivityType = that.connectivityType;
callArgs.uriPath = that.uriPath;
callArgs.options = that.options;
}
} else {
- console.log("Already stored in C++, all needed info is id");
+ privUtils_.log("Already stored in C++, all needed info is id");
}
return callArgs;
}
function manageId(that, result) {
if (result.keepId) {
that[kIdKey] = result.id;
- console.log("Keep id of resource: " + that[kIdKey]);
+ privUtils_.log("Keep id of resource: " + that[kIdKey]);
} else {
- console.log("Clear id of resource");
+ privUtils_.log("Clear id of resource");
delete that[kIdKey];
}
delete result.keepId;
var types_ = validator_.Types;
var type_ = xwalk.utils.type;
var converter_ = xwalk.utils.converter;
+var privUtils_ = xwalk.utils;
var callbackId = 0;
var callbacks = {};
var listeners = callbacks[msg['local_port_id']];
var rmp;
- console.log('Listeners length:' + listeners.length);
+ privUtils_.log('Listeners length:' + listeners.length);
if (!msg.hasOwnProperty('remotePort'))
rmp = null;
var types_ = validator_.Types;
var T_ = xwalk.utils.type;
var native = new xwalk.utils.NativeManager(extension);
+var privUtils_ = xwalk.utils;
function throwException_(err) {
throw new WebAPIException(err.code, err.name, err.message);
* }
*
* m.name = 'A brand new name';
- * console.log(m.name); // Name
+ * privUtils_.log(m.name); // Name
*/
function propertyFactory_(that, name, value, flags, options) {
flags = flags || 0;
return;
}
- console.log('Current result: ' + result);
+ privUtils_.log('Current result: ' + result);
var result_array = {};
for (var i in result.result) {
d = new Reader(msg.handle);
break;
default:
- console.log('Unknown mode: ' + msg.action);
+ privUtils_.log('Unknown mode: ' + msg.action);
return;
}
var callArgs = { handle: reader_handle };
var result = native_.callSync('SEReader_isPresent', callArgs);
if (native_.isFailure(result)) {
- console.log('SEReader_isPresent error: ' + native_.getErrorObject(result));
+ privUtils_.log('SEReader_isPresent error: ' + native_.getErrorObject(result));
return false;
} else {
return native_.getResultObject(result);
var callArgs = { handle: session_handle };
var result = native_.callSync('SESession_isClosed', callArgs);
if (native_.isFailure(result)) {
- console.log('SESession_isClosed error: ' + native_.getErrorObject(result));
+ privUtils_.log('SESession_isClosed error: ' + native_.getErrorObject(result));
return true;
} else {
return native_.getResultObject(result);
if (propertyId) {
_propertyContainer[propertyId].broadcastFunction(msg);
} else {
- console.log("No propertyId provided - ignoring");
+ privUtils_.log("No propertyId provided - ignoring");
}
}
native_.addListener("SysteminfoCommonListenerLabel", _listenerFunction);
} catch (e) {
// if it is "auto" timeout call it should not throw an exception
if (isTimeout) {
- console.log('Listener was already deleted');
+ privUtils_.log('Listener was already deleted');
return;
}
throw e;
switch (tzName) {
case _LOCAL_ID:
- console.log('Entered _constructTZDate for local timezone');
+ utils_.log('Entered _constructTZDate for local timezone');
tzName = tizen.time.getLocalTimezone();
break;
case _GMT_ID:
- console.log('Entered _constructTZDate for GMT');
+ utils_.log('Entered _constructTZDate for GMT');
if (T.isNullOrUndefined(offset)) {
offset = 0;
break;
default:
- console.log('Entered _constructTZDate for: ' + tzName);
+ utils_.log('Entered _constructTZDate for: ' + tzName);
if (T.isNullOrUndefined(offset)) {
// throws if tzName is invalid
offset = _getTimezoneOffset(utcTimestamp, tzName).offset;
//class TZDate ////////////////////////////////////////////////////
tizen.TZDate = function(p1, p2, day, hours, minutes, seconds, milliseconds, timezone) {
- console.log("Entered tizen.TZDate");
+ utils_.log("Entered tizen.TZDate");
validator_.validateConstructorCall(this, tizen.TZDate);
var priv;
priv = p1;
} else {
//Public constructor section
- console.log('Entered TZDate constructor with: ' + arguments.length + ' attributes');
+ utils_.log('Entered TZDate constructor with: ' + arguments.length + ' attributes');
var date;
};
tizen.TZDate.prototype.getDate = function() {
- console.log('Entered TZDate.getDate');
+ utils_.log('Entered TZDate.getDate');
//getters realized with pattern
//---> use _shiftedTimestamp (_utcTimestamp (UTC) with added _timezoneOffset)
//---> create Date instance
}
tizen.TZDate.prototype.setDate = function() {
- console.log('Entered TZDate.setDate');
+ utils_.log('Entered TZDate.setDate');
_updateTZDate(this, arguments, 'date', 'setUTCDate');
};
tizen.TZDate.prototype.getDay = function() {
- console.log('Entered TZDate.getDay');
+ utils_.log('Entered TZDate.getDay');
return _createShiftedDate(this).getUTCDay();
};
tizen.TZDate.prototype.getFullYear = function() {
- console.log('Entered TZDate.getFullYear');
+ utils_.log('Entered TZDate.getFullYear');
return _createShiftedDate(this).getUTCFullYear();
};
tizen.TZDate.prototype.setFullYear = function() {
- console.log('Entered TZDate.setFullYear');
+ utils_.log('Entered TZDate.setFullYear');
_updateTZDate(this, arguments, 'year', 'setUTCFullYear');
};
tizen.TZDate.prototype.getHours = function() {
- console.log('Entered TZDate.getHours');
+ utils_.log('Entered TZDate.getHours');
return _createShiftedDate(this).getUTCHours();
};
tizen.TZDate.prototype.setHours = function() {
- console.log('Entered TZDate.setHours');
+ utils_.log('Entered TZDate.setHours');
_updateTZDate(this, arguments, 'hours', 'setUTCHours');
};
tizen.TZDate.prototype.getMilliseconds = function() {
- console.log('Entered TZDate.getMilliseconds');
+ utils_.log('Entered TZDate.getMilliseconds');
return _createShiftedDate(this).getUTCMilliseconds();
};
tizen.TZDate.prototype.setMilliseconds = function() {
- console.log('Entered TZDate.setMilliseconds');
+ utils_.log('Entered TZDate.setMilliseconds');
_updateTZDate(this, arguments, 'ms', 'setUTCMilliseconds');
};
tizen.TZDate.prototype.getMinutes = function() {
- console.log('Entered TZDate.getMinutes');
+ utils_.log('Entered TZDate.getMinutes');
return _createShiftedDate(this).getUTCMinutes();
};
tizen.TZDate.prototype.setMinutes = function() {
- console.log('Entered TZDate.setMinutes');
+ utils_.log('Entered TZDate.setMinutes');
_updateTZDate(this, arguments, 'minutes', 'setUTCMinutes');
};
tizen.TZDate.prototype.getMonth = function() {
- console.log('Entered TZDate.getMonth');
+ utils_.log('Entered TZDate.getMonth');
return _createShiftedDate(this).getUTCMonth();
};
tizen.TZDate.prototype.setMonth = function() {
- console.log('Entered TZDate.setMonth');
+ utils_.log('Entered TZDate.setMonth');
_updateTZDate(this, arguments, 'month', 'setUTCMonth');
};
tizen.TZDate.prototype.getSeconds = function() {
- console.log('Entered TZDate.getSeconds');
+ utils_.log('Entered TZDate.getSeconds');
return _createShiftedDate(this).getUTCSeconds();
};
tizen.TZDate.prototype.setSeconds = function() {
- console.log('Entered TZDate.setSeconds');
+ utils_.log('Entered TZDate.setSeconds');
_updateTZDate(this, arguments, 'seconds', 'setUTCSeconds');
};
tizen.TZDate.prototype.getUTCDate = function() {
- console.log('Entered TZDate.getUTCDate');
+ utils_.log('Entered TZDate.getUTCDate');
return _createUTCDate(this).getUTCDate();
};
tizen.TZDate.prototype.setUTCDate = function() {
- console.log('Entered TZDate.setUTCDate');
+ utils_.log('Entered TZDate.setUTCDate');
_updateTZDateUTC(this, arguments, 'date', 'setUTCDate');
};
tizen.TZDate.prototype.getUTCDay = function() {
- console.log('Entered TZDate.getUTCDay');
+ utils_.log('Entered TZDate.getUTCDay');
return _createUTCDate(this).getUTCDay();
};
tizen.TZDate.prototype.getUTCFullYear = function() {
- console.log('Entered TZDate.getUTCFullYear');
+ utils_.log('Entered TZDate.getUTCFullYear');
return _createUTCDate(this).getUTCFullYear();
};
tizen.TZDate.prototype.setUTCFullYear = function() {
- console.log('Entered TZDate.setUTCFullYear');
+ utils_.log('Entered TZDate.setUTCFullYear');
_updateTZDateUTC(this, arguments, 'year', 'setUTCFullYear');
};
tizen.TZDate.prototype.getUTCHours = function() {
- console.log('Entered TZDate.getUTCHours');
+ utils_.log('Entered TZDate.getUTCHours');
return _createUTCDate(this).getUTCHours();
};
tizen.TZDate.prototype.setUTCHours = function() {
- console.log('Entered TZDate.setUTCHours');
+ utils_.log('Entered TZDate.setUTCHours');
_updateTZDateUTC(this, arguments, 'hours', 'setUTCHours');
};
tizen.TZDate.prototype.getUTCMilliseconds = function() {
- console.log('Entered TZDate.getUTCMilliseconds');
+ utils_.log('Entered TZDate.getUTCMilliseconds');
return _createUTCDate(this).getUTCMilliseconds();
};
tizen.TZDate.prototype.setUTCMilliseconds = function() {
- console.log('Entered TZDate.setUTCMilliseconds');
+ utils_.log('Entered TZDate.setUTCMilliseconds');
_updateTZDateUTC(this, arguments, 'ms', 'setUTCMilliseconds');
};
tizen.TZDate.prototype.getUTCMinutes = function() {
- console.log('Entered TZDate.getUTCMinutes');
+ utils_.log('Entered TZDate.getUTCMinutes');
return _createUTCDate(this).getUTCMinutes();
};
tizen.TZDate.prototype.setUTCMinutes = function() {
- console.log('Entered TZDate.setUTCMinutes');
+ utils_.log('Entered TZDate.setUTCMinutes');
_updateTZDateUTC(this, arguments, 'minutes', 'setUTCMinutes');
};
tizen.TZDate.prototype.getUTCMonth = function() {
- console.log('Entered TZDate.getUTCMonth');
+ utils_.log('Entered TZDate.getUTCMonth');
return _createUTCDate(this).getUTCMonth();
};
tizen.TZDate.prototype.setUTCMonth = function() {
- console.log('Entered TZDate.setUTCMonth');
+ utils_.log('Entered TZDate.setUTCMonth');
_updateTZDateUTC(this, arguments, 'month', 'setUTCMonth');
};
tizen.TZDate.prototype.getUTCSeconds = function() {
- console.log('Entered TZDate.getUTCSeconds');
+ utils_.log('Entered TZDate.getUTCSeconds');
return _createUTCDate(this).getUTCSeconds();
};
tizen.TZDate.prototype.setUTCSeconds = function() {
- console.log('Entered TZDate.setUTCSeconds');
+ utils_.log('Entered TZDate.setUTCSeconds');
_updateTZDateUTC(this, arguments, 'seconds', 'setUTCSeconds');
};
tizen.TZDate.prototype.getTimezone = function() {
- console.log('Entered TZDate.getTimezone');
+ utils_.log('Entered TZDate.getTimezone');
return this._timezoneName;
};
tizen.TZDate.prototype.toTimezone = function() {
- console.log('Entered TZDate.toTimezone');
+ utils_.log('Entered TZDate.toTimezone');
var args = validator_.validateMethod(arguments, [
{
name : 'timezone',
};
tizen.TZDate.prototype.toLocalTimezone = function() {
- console.log('Entered TZDate.toLocalTimezone');
+ utils_.log('Entered TZDate.toLocalTimezone');
return new tizen.TZDate(new PrivateTZDate(this._utcTimestamp, _LOCAL_ID));
};
tizen.TZDate.prototype.toUTC = function() {
- console.log('Entered TZDate.toUTC');
+ utils_.log('Entered TZDate.toUTC');
return new tizen.TZDate(new PrivateTZDate(this._utcTimestamp, _GMT_ID));
};
tizen.TZDate.prototype.difference = function() {
- console.log('Entered TZDate.difference');
+ utils_.log('Entered TZDate.difference');
var args = validator_.validateMethod(arguments, [
{
name : 'other',
};
tizen.TZDate.prototype.equalsTo = function() {
- console.log('Entered TZDate.equalsTo');
+ utils_.log('Entered TZDate.equalsTo');
var args = validator_.validateMethod(arguments, [
{
name : 'other',
};
tizen.TZDate.prototype.earlierThan = function() {
- console.log('Entered TZDate.earlierThan');
+ utils_.log('Entered TZDate.earlierThan');
var args = validator_.validateMethod(arguments, [
{
name : 'other',
};
tizen.TZDate.prototype.laterThan = function() {
- console.log('Entered TZDate.laterThan');
+ utils_.log('Entered TZDate.laterThan');
var args = validator_.validateMethod(arguments, [
{
name : 'other',
};
tizen.TZDate.prototype.addDuration = function() {
- console.log('Entered TZDate.addDuration');
+ utils_.log('Entered TZDate.addDuration');
var args = validator_.validateMethod(arguments, [
{
name : 'duration',
};
tizen.TZDate.prototype.toLocaleDateString = function() {
- console.log('Entered TZDate.toLocaleDateString');
+ utils_.log('Entered TZDate.toLocaleDateString');
var result = native_.callSync('TZDate_toLocaleDateString',
{timezone: String(this._timezoneName),
timestamp: String(this._utcTimestamp)});
};
tizen.TZDate.prototype.toLocaleTimeString = function() {
- console.log('Entered TZDate.toLocaleTimeString');
+ utils_.log('Entered TZDate.toLocaleTimeString');
var result = native_.callSync('TZDate_toLocaleTimeString',
{timezone: String(this._timezoneName),
timestamp: String(this._utcTimestamp)});
};
tizen.TZDate.prototype.toLocaleString = function() {
- console.log('Entered TZDate.toLocaleString');
+ utils_.log('Entered TZDate.toLocaleString');
var result = native_.callSync('TZDate_toLocaleString',
{timezone: String(this._timezoneName),
timestamp: String(this._utcTimestamp)});
};
tizen.TZDate.prototype.toDateString = function() {
- console.log('Entered TZDate.toDateString');
+ utils_.log('Entered TZDate.toDateString');
var result = native_.callSync('TZDate_toDateString',
{timezone: String(this._timezoneName),
timestamp: String(this._utcTimestamp)});
};
tizen.TZDate.prototype.toTimeString = function() {
- console.log('Entered TZDate.toTimeString');
+ utils_.log('Entered TZDate.toTimeString');
var result = native_.callSync('TZDate_toTimeString',
{timezone: String(this._timezoneName),
timestamp: String(this._utcTimestamp)});
};
tizen.TZDate.prototype.toString = function() {
- console.log('Entered TZDate.toString');
+ utils_.log('Entered TZDate.toString');
var result = native_.callSync('TZDate_toString',
{timezone: String(this._timezoneName),
timestamp: String(this._utcTimestamp)});
};
tizen.TZDate.prototype.getTimezoneAbbreviation = function() {
- console.log('Entered TZDate.getTimezoneAbbreviation');
+ utils_.log('Entered TZDate.getTimezoneAbbreviation');
console.warn('DEPRECATION WARNING: getTimezoneAbbreviation() is deprecated and will be removed from next release.');
var result = native_.callSync('TZDate_getTimezoneAbbreviation',
};
tizen.TZDate.prototype.secondsFromUTC = function() {
- console.log('Entered TZDate.secondsFromUTC');
+ utils_.log('Entered TZDate.secondsFromUTC');
return -this._timezoneOffset/1000;
};
tizen.TZDate.prototype.isDST = function() {
- console.log('Entered TZDate.isDST');
+ utils_.log('Entered TZDate.isDST');
var result = native_.callSync('TZDate_isDST',
{timezone: String(this._timezoneName),
timestamp: String(this._utcTimestamp)});
};
tizen.TZDate.prototype.getPreviousDSTTransition = function() {
- console.log('Entered TZDate.getPreviousDSTTransition');
+ utils_.log('Entered TZDate.getPreviousDSTTransition');
var result = native_.callSync('TZDate_getPreviousDSTTransition',
{timezone: String(this._timezoneName),
timestamp: String(this._utcTimestamp)});
};
tizen.TZDate.prototype.getNextDSTTransition = function() {
- console.log('Entered TZDate.getNextDSTTransition');
+ utils_.log('Entered TZDate.getNextDSTTransition');
var result = native_.callSync('TZDate_getNextDSTTransition',
{timezone: String(this._timezoneName),
timestamp: String(this._utcTimestamp)});
//class tizen.TimeDuration ////////////////////////////////////////////////////
tizen.TimeDuration = function(length, unit) {
- console.log('Entered TimeDuration constructor');
+ utils_.log('Entered TimeDuration constructor');
validator_.validateConstructorCall(this, tizen.TimeDuration);
var l, u;
if (arguments.length >= 2) {
}
tizen.TimeDuration.prototype.difference = function() {
- console.log('Entered TimeDuration.difference');
+ utils_.log('Entered TimeDuration.difference');
var args = validator_.validateMethod(arguments, [
{
};
tizen.TimeDuration.prototype.equalsTo = function() {
- console.log('Entered TimeDuration.equalsTo');
+ utils_.log('Entered TimeDuration.equalsTo');
var args = validator_.validateMethod(arguments, [
{
};
tizen.TimeDuration.prototype.lessThan = function() {
- console.log('Entered TimeDuration.lessThan');
+ utils_.log('Entered TimeDuration.lessThan');
var args = validator_.validateMethod(arguments, [
{
};
tizen.TimeDuration.prototype.greaterThan = function() {
- console.log('Entered TimeDuration.greaterThan');
+ utils_.log('Entered TimeDuration.greaterThan');
var args = validator_.validateMethod(arguments, [
{
//class TimeUtil ////////////////////////////////////////////////////
exports.getCurrentDateTime = function() {
- console.log('Entered TimeUtil.getCurrentDateTime');
+ utils_.log('Entered TimeUtil.getCurrentDateTime');
return new tizen.TZDate();
};
exports.getLocalTimezone = function() {
- console.log('Entered TimeUtil.getLocalTimezone');
+ utils_.log('Entered TimeUtil.getLocalTimezone');
var result = native_.callSync('TZDate_getLocalTimezone', {});
if (native_.isFailure(result)) {
throw native_.getErrorObject(result);
var _availableTimezones = []; //an array for holding available timezones
exports.getAvailableTimezones = function() {
- console.log('Entered TimeUtil.getAvailableTimezones');
+ utils_.log('Entered TimeUtil.getAvailableTimezones');
if (_availableTimezones.length === 0) {
var result = native_.callSync('TimeUtil_getAvailableTimezones', {});
if (native_.isFailure(result)) {
};
exports.getDateFormat = function() {
- console.log('Entered TimeUtil.getDateFormat');
+ utils_.log('Entered TimeUtil.getDateFormat');
var args = validator_.validateMethod(arguments, [
{
};
exports.getTimeFormat = function() {
- console.log('Entered TimeUtil.getTimeFormat');
+ utils_.log('Entered TimeUtil.getTimeFormat');
var result = native_.callSync('TimeUtil_getTimeFormat', {});
if (native_.isFailure(result)) {
throw native_.getErrorObject(result);
};
exports.isLeapYear = function() {
- console.log('Entered TimeUtil.isLeapYear');
+ utils_.log('Entered TimeUtil.isLeapYear');
var args = validator_.validateMethod(arguments, [
{
var _timeUtilDateTimeChangeListener;
function _timeChangedListenerCallback(eventObj) {
- console.log("_timeChangedListenerCallback");
+ utils_.log("_timeChangedListenerCallback");
native_.callIfPossible(_timeUtilDateTimeChangeListener);
}
exports.setDateTimeChangeListener = function() {
- console.log('Entered TimeUtil.setDateTimeChangeListener');
+ utils_.log('Entered TimeUtil.setDateTimeChangeListener');
var args = validator_.validateMethod(arguments, [
{
name : 'changeCallback',
};
exports.unsetDateTimeChangeListener = function() {
- console.log('Entered TimeUtil.unsetDateTimeChangeListener');
+ utils_.log('Entered TimeUtil.unsetDateTimeChangeListener');
var result = native_.callSync('TimeUtil_unsetDateTimeChangeListener', {});
if (native_.isFailure(result)) {
throw native_.getErrorObject(result);
var _timeUtilTimezoneChangeListener;
function _timezoneListenerCallback(eventObj) {
- console.log("_timezoneListenerCallback");
+ utils_.log("_timezoneListenerCallback");
native_.callIfPossible(_timeUtilTimezoneChangeListener);
}
exports.setTimezoneChangeListener = function() {
- console.log('Entered TimeUtil.setTimezoneChangeListener');
+ utils_.log('Entered TimeUtil.setTimezoneChangeListener');
var args = validator_.validateMethod(arguments, [
{
name : 'changeCallback',
};
exports.unsetTimezoneChangeListener = function() {
- console.log('Entered TimeUtil.unsetTimezoneChangeListener');
+ utils_.log('Entered TimeUtil.unsetTimezoneChangeListener');
native_.removeListener('TimezoneChangeListener');
var result = native_.callSync('TimeUtil_unsetTimezoneChangeListener', {});
_timeUtilTimezoneChangeListener = undefined;
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
+var _enableJsLogs = false;
+
var _global = {};
if (typeof window != 'undefined') {
_global = window;
});
}
+Utils.prototype.log = function() {
+ if (_enableJsLogs) {
+ console.log.apply(console, arguments);
+ }
+}
+
Utils.prototype.repackFilter = function(filter) {
if (filter instanceof tizen.AttributeFilter) {
return {