function _addUIPaneItemsToApplicationState(arrayObj, pane) {
utils.forEach(arrayObj, function (domId) {
var collapsed = jQuery("#" + domId + " .info")[0];
collapsed = (collapsed.style && collapsed.style.display === "none") ? true : false;
utils.forEach(_applicationStateTmp, function (obj) {
if (obj.domId === domId) {
_applicationState.push({
"domId": domId,
"collapsed": collapsed,
"pane": pane,
"titleName" : obj.titleName,
"display" : obj.display
});
_applicationStateTmp.splice(_applicationStateTmp.indexOf(obj), 1);
return;
}
}, this);
}, this);
utils.forEach(_applicationStateTmp, function (obj) {
_applicationState.push({
"domId": obj.domId,
"collapsed": obj.collapsed,
"pane": obj.pane,
"titleName" : obj.titleName,
"display" : obj.display
});
});
}
function _xmlToJson(xml) {
var obj = {};
if (xml.nodeType === 1) { // element
if (xml.attributes.length > 0) {
obj["@attributes"] = {};
utils.forEach(xml.attributes, function (attribute) {
obj["@attributes"][attribute.nodeName] = attribute.nodeValue;
});
}
}
else if (xml.nodeType === 3) { // text node
obj = xml.nodeValue;
}
if (xml.hasChildNodes && xml.hasChildNodes()) {
utils.forEach(xml.childNodes, function (child) {
if (!child.nodeName) {
return;
}
if (!obj[child.nodeName]) {
obj[child.nodeName] = [];
}
obj[child.nodeName].push(_xmlToJson(child));
});
}
return obj;
}
utils.forEach(objects, function (obj, key) {
var objFeatures = {}, rpt, i, j;
if (obj.feature) {
objFeatures = obj.feature.split('|');
utils.forEach(objFeatures, function (feature) {
var avail = {uri: feature,
required: false,
param: null};
_availableSet[feature] = avail;
});
if (_features) {
rpt = objFeatures.length;
j = 0;
for (i = 0; i < rpt; i++) {
if (!_features[objFeatures[j]]) {
objFeatures.splice(j, 1);
} else {
j++;
}
}
}
utils.forEach(objFeatures, function (feature) {
var avail = {uri: feature,
required: true,
param: null};
_activatedSet[feature] = avail;
});
}
if (obj.children) {
populateFeatures(obj.children);
}
});
interval = window.setInterval(function () {
var removeList = [], i;
if (!_isDiscovering) {
window.clearInterval(interval);
return;
}
if (_data.availableDevsChanging) {
_data.availableDevsChanging = false;
utils.forEach(_data.historyDevs, function (item) {
if (!_data.availableDevs[item.address]) {
removeList.push(item.address);
}
});
for (i in removeList) {
successCallback.ondevicedisappeared(removeList[i]);
delete _data.historyDevs[removeList[i]];
}
utils.forEach(_data.availableDevs, function (item) {
if (!_data.historyDevs[item.address]) {
_data.historyDevs[item.address] = item;
successCallback.ondevicefound(item);
}
});
}
}, _data.DISCOVER_INTERVAL);
getDevice: function (deviceId, platform, version) {
var device = _devices[deviceId] ? utils.copy(_devices[deviceId]) : null;
if (device && platform && version) {
if (device.overrides &&
device.overrides.api &&
device.overrides.api[platform]) {
utils.forEach(device.overrides.api[platform], function (override, index) {
if (index !== "apiVersion") {
device[index] = override;
}
});
if (device.overrides.api[platform].apiVersion &&
device.overrides.api[platform].apiVersion[version]) {
utils.forEach(device.overrides.api[platform].apiVersion[version], function (override, index) {
device[index] = override;
});
}
}
delete device.overrides;
}
return device;
},
initFeaturesSet = function () {
_features = utils.copy(app.getInfo().features);
populateFeatures(platform.current().objects);
utils.forEach(_activatedSet, function (obj, key) {
_activatedFeatures.push(obj);
});
utils.forEach(_availableSet, function (obj, key) {
_availableFeatures.push(obj);
});
init_done = true;
};
function _initialize() {
_get();
utils.forEach(_data.dbStorage.directories, function (directory) {
_data.directories.push(new ContentDirectory(directory, true));
});
utils.forEach(_data.dbStorage.contents, function (content) {
_data.contents.push(new ContentFactory(content, true));
});
_data.dbStorage.directories = _data.directories;
_data.dbStorage.contents = _data.contents;
}
ls: function (path, success, error) {
try {
var dir = _get(path),
items = [];
if (dir) {
utils.forEach(dir.children, function (item) {
if (!item.isDirectory) {
item.file = function (callback) {
callback({});
};
}
items.push(item);
});
}
else {
items = {};
}
success(utils.copy(items));
}
catch (e) {
e.code = 1;
error(e);
}
},
this.removeAll = function (successCallback, errorCallback) {
var i, rtn = [];
if (!_security.removeAll) {
throw new WebAPIException(errorcode.SECURITY_ERR);
}
t.CallHistory("removeAll", arguments);
for (i = 0; i < _data.callHistory.length; i++) {
rtn.push(_rtnEntry(_data.callHistory[i]));
}
_data.callHistory = [];
_save();
utils.forEach(_data.observers, function (observer) {
observer.onchanged(rtn);
});
if (successCallback) {
setTimeout(function () {
successCallback();
}, 1);
}
};
this.removeAll = function (successCallback, errorCallback) {
var i, rtn = [];
if (!_security.all && !_security.removeAll) {
throw new WebAPIException(errorcode.SECURITY_ERR);
}
if ((successCallback && typeof successCallback !== "function") ||
(errorCallback && typeof errorCallback !== "function")) {
throw new WebAPIException(errorcode.TYPE_MISMATCH_ERR);
}
for (i = 0; i < _data.callHistory.length; i++) {
rtn.push(_rtnEntry(_data.callHistory[i]));
}
_data.callHistory = [];
_save();
if (successCallback) {
successCallback();
}
utils.forEach(_data.observers, function (observer) {
observer.onchanged(rtn);
});
},
initialize: function () {
var node = jQuery(THEME_SELECTOR),
themeToSet = db.retrieve(THEME_KEY),
themes = require('ripple/ui/themes');
if (themeToSet && !utils.some(themes, function (some, index) {
return themes[index] === themeToSet;
})) {
_saveAndReload(THEME_KEY, themes[0]);
} else {
utils.forEach(themes, function (theme) {
node.append(utils.createElement("option", {
"value": theme,
"innerHTML": theme
}));
});
if (themes.length > 1) {
node.val(themeToSet);
node.bind("change", function () {
_currentTheme = node.val();
_saveAndReload(THEME_KEY, _currentTheme);
});
} else {
jQuery(".theme-switcher").hide();
}
}
}
this.remove = function (entry) {
var isFound = false, rtn = [];
if (!_security.all && !_security.remove) {
throw new WebAPIException(errorcode.SECURITY_ERR);
}
if (!_isValidCallHistoryEntry(entry)) {
throw new WebAPIException(errorcode.TYPE_MISMATCH_ERR);
}
_data.callHistory = _data.callHistory.filter(function (element) {
return utils.some(element, function (value, key) {
if (tizen1_utils.isEqual(entry[key], value)) {
isFound = true;
return false;
}
return true;
});
});
if (!isFound) {
throw new WebAPIException(errorcode.NOT_FOUND_ERR);
}
_save();
rtn.push(_rtnEntry(entry));
utils.forEach(_data.observers, function (observer) {
observer.onchanged(rtn);
});
},
db.retrieveAll(platform.getPersistencePrefix(), function (results) {
var str = "",
counter = 0;
utils.forEach(results, function (value, key) {
// TODO: based of current platform
if (app.isPreferenceReadOnly(key)) {
str += '<tr class="ui-text-highlight">';
} else {
str += '<tr>';
}
str += '<td>' + key + '</td><td>' + value + "</td></tr>";
counter ++;
});
node.innerHTML = str;
countTitle.innerHTML = counter.toString();
if (counter === 0) {
jQuery("#" + constants.COMMON.STORAGE_CLEAR_BUTTON_ID).addClass(constants.CSS_PREFIX.IRRELEVANT);
}
else {
jQuery("#" + constants.COMMON.STORAGE_CLEAR_BUTTON_ID).removeClass(constants.CSS_PREFIX.IRRELEVANT);
}
});
function _initTimeZone() {
var allTZ, dbTZ, node = jQuery("#time-locale-select"),
timezone = require('ripple/platform/tizen/2.0/timezone_info'),
alarms, time;
function triggerAlarm() {
time = new Date();
alarms = db.retrieveObject("tizen1.0-db-alarms");
if (alarms !== null) {
utils.forEach(alarms, function (obj) {
if (obj.id !== undefined) {
event.trigger("CheckAlarm", [obj.id]);
}
});
}
}
window.setInterval(triggerAlarm, 1000);
allTZ = timezone.getAllTimezone();
utils.forEach(allTZ, function (tz) {
node.append(utils.createElement("option", {
"value": tz,
"innerHTML": tz + " - " + timezone.getTimezoneAbbr(tz) + "(" + timezone.getTimezoneDiff(tz) + ")"
}));
});
dbTZ = db.retrieve("tizen-timezone");
if (timezone.isValidTimezone(dbTZ)) {
node.val(dbTZ);
} else {
db.save("tizen-timezone", node.val());
}
node.bind("change", function () {
db.save("tizen-timezone", node.val());
});
}
function _initialize() {
var adapterName, devs;
_data.bluetoothClassDeviceMajor = new BluetoothClassDeviceMajor();
_data.bluetoothClassDeviceMinor = new BluetoothClassDeviceMinor();
_data.bluetoothClassDeviceService = new BluetoothClassDeviceService();
adapterName = db.retrieveObject(_data.DB_BLUETOOTH_KEY) ||
_data.DEFAULT_ADAPTER_NAME;
_data.adapter = new BluetoothAdapter(adapterName,
_data.DEFAULT_ADAPTER_ADDRESS);
// get defalt nearby devices
devs = db.retrieveObject("bt-simulated-devices");
utils.forEach(devs, function (item) {
if (!_data.availableDevs[item.address]) {
_data.availableDevs[item.address] = new BluetoothDevice({
name: item.name,
address: item.address,
deviceClass: item.deviceClass,
isBonded: false,
isTrusted: item.isTrusted,
isConnected: false,
services: item.services,
metaData: _security
});
}
});
}
function loadInstalledList() {
var html = "";
jQuery("#package-installed-box").empty();
utils.forEach(_data.installedList, function (item) {
html += _packageInstalledTemplate.replace(/#Name/g, item.name)
.replace(/#ID/g, item.id)
.replace(/#IconPath/, item.iconPath)
.replace(/#Version/, item.version)
.replace(/#TotalSize/, item.totalSize)
.replace(/#DataSize/, item.dataSize)
.replace(/#LastModified/, item.lastModified)
.replace(/#Author/, item.author)
.replace(/#Description/, item.description)
.replace(/#APPIDs/, item.appIds.join("<br>"));
});
$("#package-installed-box").accordion("destroy");
$("#package-installed-box").html(html).accordion({
active : false,
collapsible : true,
autoHeight : false
});
$("." + "package-remove-btn").bind("click", function () {
var id = this.id;
utils.forEach(_data.packageList, function (item) {
if (item.id === id) {
event.trigger("remove-apps", [item.appIds]);
}
});
delete _data.installedList[this.id];
_save();
loadPackageList();
loadInstalledList();
event.trigger("uninstall-package", [this.id]);
});
}
function _validateNode(schemaNode, parentNode) {
var children = utils.filter(parentNode.childNodes, function (child) {
return child && child.nodeName === schemaNode.nodeName;
});
if (children.length === 0) {
if (schemaNode.required) {
_failNodeValidation(schemaNode, " node expected, but not found", null, null);
}
else {
_createEmptyNodeValidation(schemaNode);
}
}
utils.forEach(children, function (child) {
if (schemaNode.occurrence !== 0 && schemaNode.occurrence < children.length) {
_failNodeValidation(schemaNode, " node: more then " + schemaNode.occurrence + " node(s) found", null, child);
}
else {
_validateNodeValue(schemaNode, child.childNodes[0] || child);
_validateNodeAttributes(schemaNode, child, children);
}
utils.forEach(schemaNode.children, function (schema) {
_validateNode(schema, child);
});
});
}
function getDirectories(successCallback, errorCallback) {
var result = [];
if (!_security.all && !_security.getDirectories) {
throw new WebAPIException(errorcode.SECURITY_ERR);
}
successCallback = t.ContentDirectoryArraySuccessCallback(successCallback);
errorCallback = t.ErrorCallback(errorCallback, "?");
if (_data.directories.length === 0) {
if (errorCallback) {
setTimeout(function () {
errorCallback(new WebAPIError(errorcode.UNKNOWN_ERR));
}, 1);
}
return;
}
utils.forEach(_data.directories, function (directory) {
result.push(new ContentDirectory(directory));
});
successCallback(result);
}
utils.forEach(platformList, function (platform, platformKey) {
platformNode = utils.createElement("option", {
"innerText": platformKey,
"value": platformKey
});
utils.forEach(platform, function (version, versionNumber) {
versionNode = utils.createElement("option", {
"innerText": version.text,
"value": versionNumber
});
if (currentPlatform && version.id === currentPlatform) {
if (currentVersion && currentVersion === versionNumber) {
platformNode.selected = true;
versionNode.selected = true;
}
}
if (currentPlatform && version.id === currentPlatform) {
versionSelect.appendChild(versionNode);
}
});
platformSelect.appendChild(platformNode);
});
function _getDeviceAttribute(attr) {
var devicePointer = devices.getCurrentDevice();
utils.forEach(attr.split("."), function (dot) {
devicePointer = devicePointer[dot];
});
return devicePointer;
}
function _initialize() {
_get();
utils.forEach(_data.dbStorage, function (bookmark) {
_data.bookmarks.push(new BookmarkInternal(bookmark, null));
});
}
setTimeout(function () {
isFound = entries.every(function (element) {
return _data.callHistory.some(function (callHistory) {
return element.uid === callHistory.uid;
});
});
if (!isFound) {
if (errorCallback) {
errorCallback(new WebAPIError(errorcode.NOT_FOUND_ERR));
}
return;
}
_data.callHistory = _data.callHistory.filter(function (element) {
return !entries.some(function (entryValue, entryIndex) {
return tizen1_utils.isEqual(element, entryValue);
});
});
_save();
if (successCallback) {
successCallback();
}
for (i = 0; i < entries.length; i++) {
rtn.push(_rtnEntry(entries[i]));
}
utils.forEach(_data.observers, function (observer) {
observer.onchanged(rtn);
});
}, 1);
create: function (properties) {
var contact = new Contact();
utils.forEach(properties, function (value, key) {
contact[key] = value;
});
return contact;
},
utils.forEach(_btSimulatedDevs, function (item) {
var uuidsHTML = "", firstService = null;
utils.forEach(item.services, function (s, index) {
if (!firstService) {
firstService = s;
}
uuidsHTML += '<option value="' + index + '">' + s.name + '</option>';
});
devicesHTML = _btDeviceTemplate.replace(/#name/g, item.name)
.replace(/#address/g, item.address)
.replace(/#class-major/, item.deviceClass.majorName)
.replace(/#class-minor/, item.deviceClass.minorName)
.replace(/#class-service/, item.deviceClass.servicesName.join(","))
.replace(/#bonded/, "No")
.replace(/#trusted/, item.isTrusted ? "Yes" : "No")
.replace(/#connected/, "No")
.replace(/#uuids/, uuidsHTML)
.replace(/#service-uuid/, firstService.uuid)
.replace(/#service-protocol/, firstService.protocol)
.replace(/#service-state/, firstService.state || "CLOSED")
.replace(/#id/g, item.address.replace(/:/g, ""));
btHtmlContent += devicesHTML;
});
function _loadInstalledAppList() {
var html = "";
jQuery("#application-installed-box").empty();
utils.forEach(_data.installedAppList, function (item) {
html += _appInstalledTemplate.replace(/#Name/g, item.name)
.replace(/#ID/g, item.id)
.replace(/#IconPath/, item.iconPath)
.replace(/#Version/, item.version)
.replace(/#Show/, item.show)
.replace(/#Categories/, item.categories.join("<br>"))
.replace(/#InstallDate/, item.installDate)
.replace(/#Size/, item.size)
.replace(/#PackageID/, item.packageId)
.replace(/#SharedURI/, item.sharedURI)
.replace(/#Operation/, item.operation)
.replace(/#URI/, item.appControl.uri)
.replace(/#MIME/, item.appControl.mime)
.replace(/#category/, item.appControl.category)
.replace(/#Data/, item.appControl.data);
});
jQuery("#application-installed-box").accordion("destroy");
jQuery("#application-installed-box").html(html).accordion({
active: false,
collapsible: true,
autoHeight: false
});
}
initialize: function () {
var settings;
_contentContainer = document.getElementById(_CONTAINER_ID);
settings = platform.current().device;
utils.forEach(settings, function (settingSection, settingType) {
var currentTableNode;
_contentContainer.appendChild(utils.createElement("h3", { "innerText": settingType }));
currentTableNode = utils.createElement("table", {
"class": constants.UI.PANEL_TABLE_CLASS
});
_contentContainer.appendChild(currentTableNode);
utils.forEach(settingSection, function (setting, key) {
currentTableNode.appendChild(_buildDOMNode(setting, settingType, key));
if (setting.callback) {
setting.callback(setting.control.value);
}
});
});
}
function _initContacts() {
var data = db.retrieveObject(_CONTACT_KEY),
contactsSelect = document.getElementById("call-local-phone-number"),
displayName = null, number = null, index = 0, i;
contactsSelect.innerHTML = "";
utils.forEach(data, function (addrBook) {
utils.forEach(addrBook._contacts, function (contact) {
if (contact.name && contact.name && contact.phoneNumbers &&
contact.phoneNumbers.length > 0) {
displayName = contact.name.firstName + ' ' + contact.name.lastName;
number = contact.phoneNumbers[0].number;
_contactMap[number] = displayName;
contactsSelect.appendChild(utils.createElement("option", {
"innerText": displayName + ':' + number,
"value": index
}));
index++;
}
});
});
if (displayName === null && number === null) {
for (i in _contactMap) {
displayName = _contactMap[i];
number = i;
contactsSelect.appendChild(utils.createElement("option", {
"innerText": displayName + ':' + number,
"value": index
}));
}
}
}
initialize: function () {
var settings, value;
_contentContainer = document.getElementById(_CONTAINER_ID);
_network_contentContainer = document.getElementById("networksettings-content-container");
settings = platform.current().device;
utils.forEach(settings, function (settingSection, settingType) {
var currentTableNode, currentTableNode2, settingNameNode, settingName = _retrieveSettingName(settingType);
settingNameNode = utils.createElement("h3", { "innerText": settingName });
settingNameNode.setAttribute("class", "configure-window-session-title");
if (settingType === 'NETWORK' || settingType === 'WIFI_NETWORK' || settingType === 'CELLULAR_NETWORK' || settingType === 'SIM') {
_network_contentContainer.appendChild(settingNameNode);
currentTableNode2 = utils.createElement("table", {
"class": constants.UI.PANEL_TABLE_CLASS
});
currentTableNode2.setAttribute("class", "configure-window-panel-table");
_network_contentContainer.appendChild(currentTableNode2);
}
else {
_contentContainer.appendChild(settingNameNode);
currentTableNode = utils.createElement("table", {
"class": constants.UI.PANEL_TABLE_CLASS
});
currentTableNode.setAttribute("class", "configure-window-panel-table");
_contentContainer.appendChild(currentTableNode);
}
utils.forEach(settingSection, function (setting, key) {
if (settingType === 'NETWORK' || settingType === 'WIFI_NETWORK' || settingType === 'CELLULAR_NETWORK' || settingType === 'SIM') {
currentTableNode2.appendChild(_buildDOMNode(setting, settingType, key));
}
else {
currentTableNode.appendChild(_buildDOMNode(setting, settingType, key));
}
value = _getCurrentSetting(setting, settingType, key);
if (setting.callback) {
setting.callback(value);
}
});
});
if (deviceSettings.retrieve("CELLULAR_NETWORK.isFlightMode") === true) {
$("#device-settings-CELLULAR_NETWORK-status").parent().append("<span id='config_flight_mode_notice' style='color:#555555;'> (Disabled for Flight Mode)</span>");
document.getElementById("device-settings-CELLULAR_NETWORK-status").disabled = true;
}
event.on("DisplayBrightnessChanged", displayBrightnessCB);
event.on("DisplayBrightnessChangedByPower", displayBrightnessCB);
event.on("CpuLoadChanged", cpuLoadCB);
event.on("AvailCapacityChanged", availCapacityCB);
event.on("CpuLoadChangedByPower", cpuLoadCB);
event.on("FlightModeChanged", flightModeChangedCB);
event.on("WiFiNetworkStatusChanged", wiFiNetworkStatusCB);
event.on("CellularNetworkStatusChanged", cellularNetworkStatusCB);
event.on("LayoutChanged", layoutCB);
},
function _initExceptionTypes() {
utils.forEach(_exception, function (value, key) {
document.getElementById("call-exception-type").appendChild(utils.createElement("option", {
"innerText": value,
"value": key
}));
});
}
it("foreach_obj", function () {
utils.forEach(_foreachObj, function (x) {
x.call();
});
expect(_foreachObj.a.called).toEqual(true);
expect(_foreachObj.b.called).toEqual(true);
});