it("can_retreive_all_for_a_prefix", function () {
db.save("testKey", "test value", "testPrefix-");
db.save("testKey2", "test value 2", "testPrefix-");
db.save("testKey3", "test value 3", "testPrefix2-");
db.retrieveAll("testPrefix-", function (items) {
expect(items.testKey).toEqual("test value");
expect(items.testKey2).toEqual("test value 2");
expect(items.testKey3).toEqual(undefined);
});
});
it("removeAll_removes_all_removes_prefix_subset", function () {
db.save("testKey", "test value");
db.save("testKey", "test value", "testPrefix-");
db.removeAll("testPrefix-");
var storedValue = db.retrieve("testKey"),
prefixValue = db.retrieve("testKey", "testPrefix-");
expect(storedValue).toEqual("test value");
expect(prefixValue).toEqual(undefined);
});
setPreferenceForKey: function (preference, key) {
utils.validateNumberOfArguments(1, 2, arguments.length);
utils.validateArgumentType(key, "string");
var msg = "",
prefix = platform.getPersistencePrefix();
if (app.isPreferenceReadOnly(key)) {
msg += "Cannot modify a read only preference. Preference key: " + key;
}
else {
if (preference === null) {
msg += "deleting preference " + key;
db.remove(key, prefix);
}
else {
msg += "setting preference " + key + " == " + preference;
utils.validateArgumentType(preference, "string");
db.save(key, preference, prefix);
}
}
_console.log(msg);
event.trigger("StorageUpdatedEvent");
},
it("remove_deletes_from_local_storage_with_custom_prefix", function () {
db.save("testKey", "test value", "testPrefix-");
db.remove("testKey", "testPrefix-");
var storedValue = db.retrieve("testKey", "testPrefix-");
expect(storedValue).toEqual(undefined);
});
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());
});
}
changeLayoutType: function (layoutType) {
if (!_validateLayoutType(layoutType)) {
exception.raise(exception.types.LayoutType, "unknown layout type requested!");
}
db.save(constants.ENCAPSULATOR.LAYOUT, layoutType);
self.resize(devices.getCurrentDevice());
}
function _updateGpsMapZoom(goUp) {
if (goUp && _gpsMapZoomLevel < constants.GEO.MAP_ZOOM_MAX) {
_gpsMapZoomLevel++;
}
else if (!goUp && _gpsMapZoomLevel > constants.GEO.MAP_ZOOM_MIN) {
_gpsMapZoomLevel--;
}
_updateGpsMap();
db.save(constants.GEO.MAP_ZOOM_KEY, _gpsMapZoomLevel);
}
function checkResolutionSize(evt) {
var query_str, id_str, len;
query_str = "#resolution-custom-" + evt.data.msg;
id_str = "custom_" + evt.data.msg;
len = jQuery(query_str).val();
if (len >= 200 && len <= 2000) {
db.save(id_str, len);
} else {
jQuery(query_str).val(db.retrieve(id_str));
}
}
function _init() {
var db = require('ripple/db'),
utils = require('ripple/utils'),
allTZ, dbTZ, node = jQuery("#time-locale-select"),
timezone = require('ripple/platform/tizen/1.0/timezone_info'),
event = require('ripple/event'),
triggerNode = jQuery("#trigger-alarm-id"),
alarms, time, timeId;
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());
});
/* FIXME: Node "trigger-alarm-id" will be removed from Time panel
* due to "time" panel will changed to "time zone" panel(PTSDK-875)
event.on("SendTriggerAppId", function (applicationId) {
if (timeId !== undefined)
clearTimeout(timeId);
triggerNode.empty();
triggerNode.append(utils.createElement("p", {
"innerHTML": applicationId + " is triggered"
}));
triggerNode.show();
timeId = setTimeout("jQuery('#trigger-alarm-id').empty();", 10000);// Comments will disappear after 10s
});
*/
}
function _db_upgrade_for_release() {
var version = db.retrieve(constants.RELEASE_VERSION);
// version: 20121115 is the first release version
if (version === null || version === undefined || Number(version) < 20130722) {
db.remove(constants.COMMON.APPLICATION_STATE + "tizen");
db.remove(constants.COMMON.APPLICATION_STATE + "cordova");
db.remove("tizen1-db-application");
db.remove("tizen-db-package");
version = 20130722;
db.save(constants.RELEASE_VERSION, version);
}
}
utils.forEach(configPreferences, function (preference) {
preferenceName = preference.attributes.name.value;
if (preferenceName) {
widgetInfo.preferences[preferenceName] = {
"key": preferenceName,
"value": preference.attributes.value.value || "",
"readonly": preference.attributes.readonly.value === "true"
};
db.save(preferenceName,
widgetInfo.preferences[preferenceName].value,
platform.getPersistencePrefix(widgetInfo.id));
}
});
function _currentlyEnabledTheme() {
var qsSet = utils.queryString().theme,
current = db.retrieve("ui-theme") || themes[0];
function matches(something) {
return function (item) {
return something === item;
};
}
if (qsSet && themes.some(matches(qsSet))) {
current = qsSet;
db.save("ui-theme", qsSet);
}
return current;
}
changeLayoutType: function (layoutType) {
if (!_validateLayoutType(layoutType)) {
exception.raise(exception.types.LayoutType, "unknown layout type requested!");
}
db.save("layout", layoutType);
_self.resize(devices.getCurrentDevice());
if (!_win) return;
_setOrientation(layoutType);
if (_win.onorientationchange) {
_win.onorientationchange();
}
var evt = _doc.createEvent("Event");
evt.initEvent("orientationchange", true, true);
_win.dispatchEvent(evt);
}
jWorkflow.order(function (prev, baton) {
baton.take();
db.save(key, value, null, baton.pass);
}).start(function () {
}).andThen(function (prev, baton) {
baton.take();
db.save("device-key", deviceId, null, baton.pass);
}).andThen(function (prev, baton) {
}).andThen(function (prev, baton) {
//remove the persisted value for the layout
baton.take();
db.save("layout", null, null, baton.pass);
}).andThen(function () {
it("save_without_custom_prefix", function () {
db.save("testKey", "test value");
var storedValue = db.retrieve("testKey");
expect(storedValue).toEqual("test value");
});
}).andThen(function (prev, baton) {
baton.take();
db.save(constants.DEVICE.SAVED_KEY, deviceId, null, baton.pass);
}).andThen(function (prev, baton) {
}).andThen(function (prev, baton) {
//remove the persisted value for the layout
baton.take();
db.save(constants.ENCAPSULATOR.LAYOUT, null, null, baton.pass);
}).andThen(function () {
it("save_doesnt_retreive_without_prefix", function () {
db.save("testKey", "test value");
var storedValue = db.retrieve("testKey", "testPrefix-");
expect(storedValue).toBeFalsy();
});
it("save_doesnt_retreive_with_prefix", function () {
db.save("testKey", "test value", "testPrefix-");
var storedValue = db.retrieve("testKey");
expect(storedValue).toEqual(undefined);
});
node.bind("change", function () {
db.save("tizen-timezone", node.val());
});
function _persist(url) {
db.save("current-url", url);
}
function _persistRoot(url) {
db.save("root-url", url);
}
extractInfo: function (configValidationObject) {
if (!configValidationObject) {
return null;
}
var widgetInfo = {},
configFeatures,
configPreferences,
preferenceName,
platform, rst, i, j,
settingRst = {
'screen-orientation': 'portrait',
'context-menu': 'enable',
'background-support': 'disable',
encryption: 'disable',
'install-location': 'auto',
'hwkey-event': 'enable'
};
widgetInfo.id = configValidationObject.widget.validationResult[0].attributes.id.value || "";
widgetInfo.name = configValidationObject.widget.children.name.validationResult[0].value;
widgetInfo.icon = configValidationObject.widget.children.icon.validationResult[0].attributes.src.value;
widgetInfo.version = configValidationObject.widget.validationResult[0].attributes.version.value;
if (configValidationObject.widget.children.application.validationResult[0].valid) {
widgetInfo.tizenAppId = configValidationObject.widget.children.application.validationResult[0].attributes.id.value;
widgetInfo.tizenPackageId = configValidationObject.widget.children.application.validationResult[0].attributes.package.value;
}
widgetInfo.features = {};
if (configValidationObject.widget.children.setting.hasOwnProperty('validationResult') === true) {
rst = configValidationObject.widget.children.setting.validationResult;
// the first one has higher priority per platform implementation
for (i = rst.length -1 ; i >= 0; i--) {
if (rst[i].valid === true) {
for (j in rst[i].attributes) {
if (rst[i].attributes[j].value !== undefined) {
settingRst[j] = rst[i].attributes[j].value;
}
}
}
}
db.save("layout", settingRst["screen-orientation"]);
}
configFeatures = configValidationObject.widget.children.feature.validationResult;
utils.forEach(configFeatures, function (f) {
if (f.valid === true) {
var feature = {id: f.attributes.name.value,
required: f.attributes.required.valid};
widgetInfo.features[feature.id] = feature;
}
});
widgetInfo.preferences = {};
configPreferences = configValidationObject.widget.children.preference.validationResult;
platform = require('ripple/platform');
utils.forEach(configPreferences, function (preference) {
preferenceName = preference.attributes.name.value;
if (preferenceName) {
widgetInfo.preferences[preferenceName] = {
"key": preferenceName,
"value": preference.attributes.value.value || "",
"readonly": preference.attributes.readonly.value === "true"
};
db.save(preferenceName,
widgetInfo.preferences[preferenceName].value,
platform.getPersistencePrefix(widgetInfo.id));
}
});
return widgetInfo;
},