PROJECT = Settings
-VERSION := 0.0.1
+VERSION := 0.0.2
PACKAGE = $(PROJECT)-$(VERSION)
INSTALL_DIR = ${DESTDIR}/opt/usr/apps/.preinstallWidgets
[Desktop Entry]
-Version=1.0
+Version=0.0.2
Name=Settings
Comment=System Settings Application
GenericName=Settings
.network-connected .network-status {
color: green;
}
-.network-name {
- font-size: 12px;
+.network-ssid {
+ font-size: 15px;
}
-.network-authentication {
+.network-encryption {
+ font-size: 10px;
+}
+.network-strength {
font-size: 10px;
}
.network-address {
font-size: 10px;
}
.device-action-button {
- max-width: 150px;
+ max-width: 150px;
text-align: center;
}
/* Date and Time */
</div>
<div data-role="content">
+ <ul data-role="listview" data-inset="true" class="ui-listview ui-listview-inset">
+ <li data-role="fieldcontain">
+ <label for="toggle_timeupdates" class="ui-slider">Automatic time</label>
+ <select data-role="slider" name="toggle_timeupdates" id="toggle_timeupdates" class="ui-slider-switch">
+ <option value="manual">Off</option>
+ <option value="auto">On</option>
+ </select>
+ </li>
+ </ul>
<ul data-role="listview" data-inset="true" class="ui-listview ui-listview-inset">
<li data-role="fieldcontain">
- <label for="input_time">Time:</label>
- <input type="time" data-clear-btn="false" name="input_time" id="input_time" value="">
+ <label for="input_time">Time (hh:mm:ss):</label>
+ <input type="text" data-clear-btn="false" name="input_time" id="input_time" value="">
</li>
</ul>
<ul data-role="listview" data-inset="true" class="ui-listview ui-listview-inset">
<li data-role="fieldcontain">
- <label for="input_date">Date:</label>
- <input type="date" data-clear-btn="false" name="input_date" id="input_date" value="">
+ <label for="input_date">Date (yyyy-mm-dd):</label>
+ <input type="text" data-clear-btn="false" name="input_date" id="input_date" value="">
+ </li>
+ </ul>
+ <ul data-role="listview" data-inset="true" class="ui-listview ui-listview-inset">
+ <li data-role="fieldcontain">
+ <label for="toggle_timezoneupdates" class="ui-slider">Automatic time zone</label>
+ <select data-role="slider" name="toggle_timezoneupdates" id="toggle_timezoneupdates" class="ui-slider-switch">
+ <option value="manual">Off</option>
+ <option value="auto">On</option>
+ </select>
</li>
</ul>
<ul data-role="listview" data-inset="true" class="ui-listview ui-listview-inset">
};
function enableBluetooth(success_cb, error_cb) {
- wsAPI.sendRequest(WS_REQUEST_TYPE.BLUETOOTH, 'enable', null, success_cb, error_cb);
+ wsAPI.sendRequest(WS_REQUEST_TYPE.BLUETOOTH, 'enable', true, success_cb, function(e) {
+ if (e.indexOf('Already enabled') >= 0) {
+ console.log('bluetooth subsystem already enabled');
+ success_cb();
+ } else {
+ error_cb(e);
+ }
+ });
}
function disableBluetooth(success_cb, error_cb) {
- wsAPI.sendRequest(WS_REQUEST_TYPE.BLUETOOTH, 'disable', null, success_cb, error_cb);
+ wsAPI.sendRequest(WS_REQUEST_TYPE.BLUETOOTH, 'enable', false, success_cb, function(e) {
+ if (e.indexOf('Already disabled') >= 0) {
+ console.log('bluetooth subsystem already disabled');
+ success_cb();
+ } else {
+ error_cb(e);
+ }
+ });
}
function subscribeEvents(event_callback) {
}
return default_adapter;
} catch (e) {
- console.error('Tizen web api missing');
+ console.error('Tizen web api missing ' + e);
return null;
}
};
return {
BluetoothAdapter: BluetoothAdapter,
BluetoothDevice: BluetoothDevice,
- enableBluetooth: enableBluetooth,
- disableBluetooth: disableBluetooth,
subscribeEvents: subscribeEvents,
unsubscribeEvents: unsubscribeEvents,
getDefaultAdapter: getDefaultAdapter
/* Module */
settings.datetime = (function() {
+ function isTimeAuto(success_cb, error_cb) {
+ wsAPI.sendRequest(WS_REQUEST_TYPE.DATETIME, 'is_time_updates_auto', null, success_cb, error_cb);
+ }
+
+ function isTimezoneAuto(success_cb, error_cb) {
+ wsAPI.sendRequest(WS_REQUEST_TYPE.DATETIME, 'is_timezone_updates_auto', null, success_cb, error_cb);
+ }
+
function setTime(new_time, success_cb, error_cb) {
- wsAPI.sendRequest(WS_REQUEST_TYPE.DATETIME, 'setTime', new_time, success_cb, error_cb);
+ wsAPI.sendRequest(WS_REQUEST_TYPE.DATETIME, 'time', new_time, success_cb, error_cb);
}
function setTimezone(new_timezone, success_cb, error_cb) {
- wsAPI.sendRequest(WS_REQUEST_TYPE.DATETIME, 'setTimezone', new_timezone, success_cb, error_cb);
+ wsAPI.sendRequest(WS_REQUEST_TYPE.DATETIME, 'timezone', new_timezone, success_cb, error_cb);
+ }
+
+ function setTimeUpdates(manual_or_auto, success_cb, error_cb) {
+ wsAPI.sendRequest(WS_REQUEST_TYPE.DATETIME, 'time_updates', manual_or_auto, success_cb, error_cb);
+ }
+
+ function setTimezoneUpdates(manual_or_auto, success_cb, error_cb) {
+ wsAPI.sendRequest(WS_REQUEST_TYPE.DATETIME, 'timezone_updates', manual_or_auto, success_cb, error_cb);
}
return {
+ isTimeAuto: isTimeAuto,
+ isTimezoneAuto: isTimezoneAuto,
setTime: setTime,
- setTimezone: setTimezone
+ setTimezone: setTimezone,
+ setTimeUpdates: setTimeUpdates,
+ setTimezoneUpdates: setTimezoneUpdates
};
})();
\ No newline at end of file
WiFiAdapter.prototype.setPowered = function(powered, success_cb, error_cb) {
if (wsAPI === undefined) return;
- wsAPI.sendRequest(WS_REQUEST_TYPE.WIFI, 'enable', powered, success_cb, error_cb);
+ wsAPI.sendRequest(WS_REQUEST_TYPE.WIFI, 'enable', powered, success_cb, function(e) {
+ if (e.indexOf('Already enabled') >= 0) {
+ console.log('wifi subsystem already enabled');
+ success_cb();
+ } else if (e.indexOf('Already disabled') >= 0) {
+ console.log('wifi subsystem already disabled');
+ success_cb();
+ } else {
+ error_cb(e);
+ }
+ });
};
WiFiAdapter.prototype.getPowered = function(success_cb, error_cb) {
if (wsAPI === undefined) return;
var me = this;
- wsAPI.sendRequest(WS_REQUEST_TYPE.WIFI, 'isEnabled', null, function(json_msg) {
- var result = JSON.parse(json_msg);
- if (result.isEnabled === undefined) {
- console.log('Badly form json message: ' + json_msg);
+ wsAPI.sendRequest(WS_REQUEST_TYPE.WIFI, 'is_enabled', null, function(isEnabled) {
+ if (isEnabled === undefined) {
+ console.log('Badly formed json message: ' + json_msg);
}
- me.powered = result.isEnabled;
+ me.powered = isEnabled;
success_cb(me.powered);
}, error_cb);
};
WiFiAdapter.prototype.scan = function(success_cb, error_cb) {
if (wsAPI === undefined) return;
- wsAPI.sendRequest(WS_REQUEST_TYPE.WIFI, 'scan', null, function(json_msg) {
- var network_list = JSON.parse(json_msg);
- if (network_list.access_points === undefined) {
- console.log('Badly form json message: ' + json_msg);
+ wsAPI.sendRequest(WS_REQUEST_TYPE.WIFI, 'scan', null, function(results) {
+ if (results.length >= 0 && results[0].length >= 0 && results[0][0][0] === undefined) {
+ error_cb('Cannot parse scan results');
+ return;
}
- var results = [];
- for (var i = 0; i < network_list.access_points.length; i++) {
- var network = new settings.wifi.WiFiNetwork(network_list.access_points[i].ssid);
- network.connected = network_list.access_points[i].connected;
- results.push(network);
+ var network_list = results[0];
+
+ try {
+ var results = [];
+ console.log('Found ' + network_list.length + ' networks');
+ for (var i = 0; i < network_list.length; i++) {
+ if (network_list[i][1] === undefined) {
+ console.log('Badly form json message: ' + json_msg);
+ }
+ if (network_list[i][1].Type === 'wifi') {
+ var network = new settings.wifi.WiFiNetwork(network_list[i][0]);
+ if (network_list[i][1].Name !== undefined) {
+ network.ssid = network_list[i][1].Name;
+ }
+ if (network_list[i][1].State === 'ready') {
+ network.connected = true;
+ } else if (network_list[i][1].State === 'idle') {
+ network.connected = false;
+ }
+ if (network_list[i][1].EncryptionMode !== undefined) {
+ network.encryption = network_list[i][1].EncryptionMode;
+ }
+ if (network_list[i][1].Strength !== undefined) {
+ network.strength = network_list[i][1].Strength;
+ }
+ if (network_list[i][1].IPv4.Address !== undefined) {
+ network.ipAddress = network_list[i][1].IPv4.Address;
+ }
+ if (network_list[i][1].IPv4.Gateway !== undefined) {
+ network.gateway = network_list[i][1].IPv4.Gateway;
+ }
+ if (network_list[i][1].IPv4.Netmask !== undefined) {
+ network.netmask = network_list[i][1].IPv4.Netmask;
+ }
+ results.push(network);
+ }
+ }
+ } catch (e) {
+ error_cb(e);
}
success_cb(results);
}, error_cb);
};
- WiFiAdapter.prototype.connectNetwork = function(network, security, passcode, success_cb, error_cb) {
+ WiFiAdapter.prototype.connectNetwork = function(network_id, security, passcode, success_cb, error_cb) {
if (wsAPI === undefined) return;
- var connectionInfo = {
- 'ssid': network,
- 'security': security,
- 'passcode': passcode
- };
- wsAPI.sendRequest(WS_REQUEST_TYPE.WIFI, 'connect', connectionInfo, success_cb, error_cb);
+
+ wsAPI.sendRequest(WS_REQUEST_TYPE.WIFI, 'connect', network_id, success_cb, error_cb);
};
WiFiAdapter.prototype.disconnectNetwork = function(network, success_cb, error_cb) {
};
/* Network class */
- WiFiNetwork = function(ssid) {
- this.ssid = ssid;
+ WiFiNetwork = function(object_path) {
+ this.id = object_path;
+ this.ssid = '';
+ this.connected = false;
this.security = WIFI_SECURITY_TYPE.NONE;
+ this.encryption = 'Unknown';
+ this.ipAddress = 'Unknown';
+ this.gateway = 'Unknown';
+ this.netmask = 'Unknown';
+ this.strength = -1;
};
WiFiNetwork.prototype.getSecurity = function() {
function disconnected(e) {
console.log('Settings daemon disconnected...');
- showMsg('Error', e);
+ if (e == null) {
+ showMsg('Error', 'Cannot connect to settings daemon');
+ } else {
+ showMsg('Error', e);
+ }
}
function init() {
- console.log('Settings init...');
+ console.log('Settings started...');
$('#quit').on('click', function() {
console.log('Settings exiting...');
tizen.application.getCurrentApplication().exit();
if (adapter.powered) {
bluetoothToggleOn();
- bluetoothStartScan(adapter);
+ adapter.stopScanDevices(function() {
+ bluetoothStartScan(adapter);
+ }, null);
} else {
bluetoothToggleOff();
}
});
$('#toggle_bluetooth').change(function() {
- var bt_switch = $(this);
var adapter = settings.bluetooth.getDefaultAdapter();
if (adapter === null) {
showMsg('Error', 'Bluetooth adapter not found');
return;
}
- if (bt_switch[0].selectedIndex === 0) {
- console.log('Stop bluetooth scanning');
- bluetoothStopScan(adapter);
- /* first disable adapter, then disable bluetooth */
- adapter.setPowered(false, function() {
+ if ($('#toggle_bluetooth').val() === 'off') {
+ /* stop scan, then disable bluetooth */
+ adapter.stopScanDevices(function() {
/* success */
- console.log('Power off adapter success, adapter is powered: ' + adapter.powered);
- settings.bluetooth.disableBluetooth(function() {
+ console.log('Bluetooth scan canceled');
+ $('#button_bluetooth_scan .ui-btn-text').text('Scan');
+ adapter.setPowered(false, function() {
/* success */
- console.log('Bluetooth subsystem turned off');
+ console.log('Power off adapter success, adapter is powered: ' + adapter.powered);
bluetoothToggleOff();
}, function(e) {
- console.log('Failed to turn off bluetooth subsystem: ' + e);
- $('#toggle_bluetooth').val('on').slider('refresh');
- showMsg('Error', 'Cannot turn off bluetooth subsystem: ' + e);
+ /* error */
+ bluetoothToggleOn();
+ showMsg('Error', 'Cannot turn off bluetooth adapter: ' + e);
});
}, function(e) {
/* error */
- console.log('Power off adapter failed, adapter is powered: ' + adapter.powered);
$('#toggle_bluetooth').val('on').slider('refresh');
- showMsg('Error', 'Cannot turn off bluetooth adapter: ' + e);
+ showMsg('Error', 'Cannot cancel scan: ' + e);
});
} else {
- /* first enable bluetooth, then enable adapter */
- settings.bluetooth.enableBluetooth(function() {
- console.log('Bluetooth subsystem turned on');
+ adapter.setPowered(true, function() {
/* success */
- adapter.setPowered(true, function() {
- /* success */
- console.log('Power on adapter success, adapter is powered: ' + adapter.powered);
- bluetoothToggleOn();
- console.log('Start scanning...');
- bluetoothStartScan(adapter);
- }, function(e) {
- /* error */
- $('#toggle_bluetooth').val('off').slider('refresh');
- showMsg('Error', 'Cannot turn on bluetooth adapter: ' + e);
- });
+ console.log('Power on adapter success, adapter is powered: ' + adapter.powered);
+ bluetoothToggleOn();
+ bluetoothStartScan(adapter);
}, function(e) {
/* error */
- $('#toggle_bluetooth').val('off').slider('refresh');
- showMsg('Error', 'Cannot turn on bluetooth subsystem: ' + e);
+ bluetoothToggleOff();
+ showMsg('Error', 'Cannot turn on bluetooth adapter: ' + e);
});
}
});
/* Bluetooth device detail page */
$('#page_bluetooth_detail').on('pageshow', function(event, data) {
- console.log('Entering bluetooth detail info page');
var device_id = localStorage.getItem('bluetooth_device_id');
if (device_id == undefined) return;
var device = $(jqId(device_id)).data('device-object');
function bluetoothStartScan(adapter) {
/* clear the device list with new scan */
bluetoothClearAvailableList();
+
adapter.startScanDevices({
/* success */
onstarted: function() {
ondevicedisappeared: function(address) {
if ($(jqId(address)).length) {
bluetoothRemoveFromAvailableList(address);
- console.log('Remove device element from page ' + address);
}
},
onfinished: function(devices) {
}
function bluetoothAppendToPairedList(device) {
- console.log('Append to paired list - ' + device.address);
if ($('#listview_device_paired').find(jqId(device.address)).length != 0) return;
var parent = '#listview_device_paired';
});
if (removeThis.length !== 0) {
- console.log('Remove from paired list - ' + device_addr);
removeThis.remove();
bluetoothRefreshList();
}
}
function bluetoothAppendToAvailableList(device) {
- console.log('Append to available list - ' + device.address);
if ($('#listview_device_available').find(jqId(device.address)).length != 0) return;
var parent = '#listview_device_available';
});
if (removeThis.length !== 0) {
- console.log('Remove from available list: ' + device_addr);
removeThis.remove();
bluetoothRefreshList();
}
/* store device object in the element so we can reference it later */
$(jqId(device.address)).data('device-object', device);
- console.log('Storing device object: ' + jqId(device.address));
$(jqId(device.address)).on('click', function() {
localStorage.setItem('bluetooth_device_id', device.address);
$(jqId(device.address)).find('div.device-action-button').on('click', function(e) {
var parent = $(this).parent().attr('id');
- console.log('device action button clicked');
/*
* prevent the click event to propagate up
showMsg('Error', 'Not suppported');
} else if (device.connected) {
console.log('Bluetooth disconnect with device: ' + device.address);
- showSpinner(false, 'Disconnecting...');
- // adapter.disconnectDevice(device.address, function() {
- setTimeout(function() {
- /* success */
- hideSpinner();
- device.connected = false;
- bluetoothUpdateDevice(device);
- }, 1000);
+ showMsg('Error', 'Not suppported');
}
});
}
function bluetoothUpdateDevice(device) {
- console.log('Constructing or updating bluetooth device');
-
/* reposition device if it's paired or unpaired */
if (device.paired) {
bluetoothRemoveFromAvailableList(device.address);
}
function bluetoothToggleOn() {
- $('#bluetooth_devices').show();
- $('#toggle_bluetooth').val('on').slider('refresh');
+ setTimeout(function() {
+ $('#bluetooth_devices').show();
+ $('#toggle_bluetooth').val('on').slider('refresh');
+ }, 100);
}
function bluetoothToggleOff() {
- $('#bluetooth_devices').hide();
- $('#toggle_bluetooth').val('off').slider('refresh');
+ setTimeout(function() {
+ $('#bluetooth_devices').hide();
+ $('#toggle_bluetooth').val('off').slider('refresh');
+ }, 100);
}
\ No newline at end of file
*
*/
+var clockTimer = null;
+var timeChanged = false;
+var dateChanged = false;
+var timezoneChanged = false;
+var automaticTime = false;
+var automaticTimezone = false;
+
function datetimePanelInit() {
- var clockTimer = null;
- var timeChanged = false;
- var timezoneChanged = false;
/* Display Settings Panel */
$('#page_datetime').on('pageshow', function() {
- console.log('Date and time settings entered');
datetimePageReload();
});
+ $('#toggle_timeupdates').change(function() {
+ if ($('#toggle_timeupdates').val() === 'auto') {
+ settings.datetime.setTimeUpdates("auto", function() {
+ datetimePageReload();
+ }, function(e) {
+ timeUpdatesToggle('manual');
+ datetimePageReload();
+ showMsg('Error', 'Cannot set time updates to automatic: ' + e);
+ });
+ } else {
+ settings.datetime.setTimeUpdates("manual", function() {
+ datetimePageReload();
+ }, function(e) {
+ timeUpdatesToggle('auto');
+ datetimePageReload();
+ showMsg('Error', 'Cannot set time updates to manual: ' + e);
+ });
+ }
+ });
+
$('#input_time').on('change', function(event, data) {
+ console.log('input_time changed');
+ if (automaticTime) return;
+
+ var re = /^([01]?[0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9]$/;
+ if (this.value === '' || !this.value.match(re)) {
+ datetimeHideOption();
+ showMsg('Error', 'Invalid time format (hh:mm:ss): ' + this.value);
+ return;
+ }
+
timeChanged = true;
- var time = this.value;
- console.log('time value changed: ' + time);
- datetimeStopTimer();
datetimeShowOption();
});
- $('#input_time').on('focus', function(event, data) {
- datetimeStopTimer();
+ $('#input_date').on('change', function(event, data) {
+ console.log('input_date changed');
+ if (automaticTime) return;
+
+ var re = /^\d{4}-(0?[1-9]|1[012])-(0?[1-9]|[12][0-9]|3[01])$/;
+ if (this.value === '' || !this.value.match(re)) {
+ datetimeHideOption();
+ showMsg('Error', 'Invalid date format (yyyy-mm-dd): ' + this.value);
+ return;
+ }
+
+ dateChanged = true;
datetimeShowOption();
});
- $('#input_date').on('change', function(event, data) {
- timeChanged = true;
- var date = this.value;
- console.log('date value changed: ' + date);
- datetimeShowOption();
+ $('#toggle_timezoneupdates').change(function() {
+ if ($('#toggle_timezoneupdates').val() === 'auto') {
+ settings.datetime.setTimezoneUpdates("auto", function() {
+ datetimePageReload();
+ automaticTimezone = true;
+ }, function(e) {
+ timezoneUpdatesToggle('manual');
+ datetimePageReload();
+ showMsg('Error', 'Cannot set timezone updates to automatic: ' + e);
+ });
+ } else {
+ settings.datetime.setTimezoneUpdates("manual", function() {
+ datetimePageReload();
+ automaticTimezone = false;
+ }, function(e) {
+ timezoneUpdatesToggle('auto');
+ datetimePageReload();
+ showMsg('Error', 'Cannot set time zone updates to manual: ' + e);
+ });
+ }
});
$('#select_timezone').on('change', function(event, data) {
+ console.log('select_timezone changed');
+ if (automaticTimezone) return;
+
/* ignore change due to getLocalTimezone() */
if (data === false) return;
timezoneChanged = true;
var timezone = this.value;
- console.log('timezone value changed: ' + timezone);
+ console.log('time zone show option');
datetimeShowOption();
});
$('#button_datetime_apply').on('click', function(event, data) {
- if (timeChanged) {
+ if (timeChanged || dateChanged) {
timeChanged = false;
+ dateChanged = false;
updateSystemTime();
}
+
if (timezoneChanged) {
timezoneChanged = false;
updateSystemTimezone();
}
- dateChanged = false;
datetimeHideOption();
});
function datetimePageReload() {
var current = null;
timeChanged = false;
+ dateChanged = false;
timezoneChanged = false;
datetimeHideOption();
+ settings.datetime.isTimeAuto(function(isAuto) {
+ automaticTime = isAuto;
+ if (isAuto) {
+ timeUpdatesToggle('auto');
+ } else {
+ timeUpdatesToggle('manual');
+ }
+ }, function(e) {
+ showMsg('Error', e);
+ });
+
+ settings.datetime.isTimezoneAuto(function(isAuto) {
+ automaticTimezone = isAuto;
+ if (isAuto) {
+ timezoneUpdatesToggle('auto');
+ } else {
+ timezoneUpdatesToggle('manual');
+ }
+ }, function(e) {
+ showMsg('Error', e);
+ });
+
current = new Date();
console.log('Local datetime is ' + current.toISOString());
if (tizen.time) {
var alltimezones = tizen.time.getAvailableTimezones();
- console.log('Supports ' + alltimezones.length + ' time zones.');
console.log('Local timezone: ' + tizen.time.getLocalTimezone());
if (alltimezones.length > 0) {
$('#select_timezone').empty();
}
function datetimeStartTimer() {
- console.log('Start clock timer');
+ datetimeStopTimer();
clockTimer = setInterval(dateTimeUpdateClock, 1000);
}
function datetimeStopTimer() {
if (clockTimer) {
- console.log('Stop clock timer');
clearInterval(clockTimer);
}
}
var timeStr = datetimeGetStr(current.getHours()) + ':';
timeStr += datetimeGetStr(current.getMinutes()) + ':';
timeStr += datetimeGetStr(current.getSeconds());
- $('#input_time').val(timeStr);
+
+ var dateStr = datetimeGetStr(current.getFullYear()) + '-';
+ dateStr += datetimeGetStr(current.getMonth()) + '-';
+ dateStr += datetimeGetStr(current.getDate());
+
+ if (!timeChanged && !$("#input_time").is(":focus")) {
+ $('#input_time').val(timeStr);
+ }
+
+ if (!dateChanged && !$("#input_date").is(":focus")) {
+ $('#input_date').val(dateStr);
+ }
}
function updateSystemTime() {
var time = $('#input_date').val() + ' ' + $('#input_time').val();
+ if (time.split(":").length - 1 == 1) {
+ /* this is a bug where seconds are not set after date picker is launched */
+ time += ':00';
+ }
+
/* settings daemon expects number of seconds since midnight Jan 1, 1970 */
- var epoch_time = new Date(time).getTime() / 1000;
- console.log('System time set to: ' + time + ' or ' + epoch_time + ' seconds since 1/1/1970');
+ var year = Number(time.split(" ")[0].split('-')[0]);
+ var month = Number(time.split(" ")[0].split('-')[1]);
+ var day = time.split(" ")[0].split('-')[2];
+ var hour = Number(time.split(" ")[1].split(':')[0]);
+ var minute = Number(time.split(" ")[1].split(':')[1]);
+ var second = Number(time.split(" ")[1].split(':')[2]);
+ var date = new Date(year, month, day, hour, minute, second, 0);
+ var epoch_time = date.getTime() / 1000;
settings.datetime.setTime(epoch_time, function() {
- console.log('System time set successfully');
+ console.log('System time is set to: ' + date + ' or ' + epoch_time + ' seconds since 1/1/1970');
+ datetimePageReload();
}, function(e) {
showMsg('Error', 'Cannot set system time: ' + e);
+ datetimePageReload();
});
}
} else {
return '' + value;
}
+}
+
+function timeUpdatesToggle(value) {
+ if (value !== 'auto' && value !== 'manual') return;
+
+ if (value === 'auto') {
+ $('#input_time').attr('readonly', true);
+ $('#input_date').attr('readonly', true);
+ } else {
+ $('#input_time').attr('readonly', false);
+ $('#input_date').attr('readonly', false);
+ }
+ setTimeout(function() {
+ $('#toggle_timeupdates').val(value).slider('refresh');
+ }, 100);
+}
+
+function timezoneUpdatesToggle(value) {
+ if (value !== 'auto' && value !== 'manual') return;
+
+ if (value === 'auto') {
+ $('#select_timezone').selectmenu('disable');
+ } else {
+ $('#select_timezone').selectmenu('enable');
+ }
+ setTimeout(function() {
+ $('#toggle_timezoneupdates').val(value).slider('refresh');
+ }, 100);
}
\ No newline at end of file
* http://www.apache.org/licenses/LICENSE-2.0
*
*/
+var wifiScanInProgress = false;
function wifiPanelInit() {
showMsg('Error', 'WiFi adapter not found');
return;
}
- console.log('Default WiFi adapter: ', adapter.name);
if (adapter.name != undefined) {
$('#label_wifi_adapter').html(adapter.name);
}
adapter.getPowered(function(is_powered) {
- if (adapter.powered) {
+ if (is_powered) {
wifiToggleOn();
wifiScan(adapter);
} else {
});
$('#toggle_wifi').change(function() {
- var wifi_switch = $(this);
+ if (wifiScanInProgress) return;
+
var adapter = settings.wifi.getDefaultAdapter();
if (adapter === null) {
showMsg('Error', 'WiFi adapter not found');
return;
}
- if (wifi_switch[0].selectedIndex === 0) {
+ if ($('#toggle_wifi').val() === 'off') {
adapter.setPowered(false, function() {
/* success */
console.log('Successfully disable wifi subsystem');
+ wifiToggleOff();
}, function(e) {
/* error */
- $('#toggle_wifi').val('on').slider('refresh');
+ wifiToggleOn();
showMsg('Error', 'Cannot disable WiFi subsystem: ' + e);
});
} else {
adapter.setPowered(true, function() {
/* success */
console.log('Successfully enable WiFi subsystem');
+ wifiToggleOn();
wifiScan(adapter);
}, function(e) {
/* error */
- $('#toggle_wifi').val('off').slider('refresh');
+ wifiToggleOff();
showMsg('Error', 'Cannot enable WiFi subsystem: ' + e);
});
}
});
$('#button_wifi_add').on('click', function() {
+ if (wifiScanInProgress) return;
+
+ /* Not fully implemented, disable for now */
+ showMsg('Error', 'Not supported');
+ return;
+
var adapter = settings.wifi.getDefaultAdapter();
if (adapter === null) {
showMsg('Error', 'WiFi adapter not found');
/* WiFi network detail page */
$('#page_wifi_detail').on('pageshow', function(event, data) {
- console.log('Entering WiFi detail info page');
var network_id = localStorage.getItem('wifi_network_id');
if (network_id == undefined) return;
var network = $(jqId(network_id)).data('network-object');
/* WiFi add new network page */
$('#page_wifi_add').on('pagebeforeshow', function(event, data) {
- console.log('Entering wifi add network page');
$('#input_wifi_ssid').val('');
$('#input_wifi_password').val('');
$('#select_wifi_security').val('None').change();
var security_option = $('#select_wifi_security').val();
var passcode = $('#input_wifi_password').val();
- console.log(ssid);
if (ssid === '') {
showMsg('Error', 'Enter SSID');
return;
$('#select_wifi_security').on('change', function(event, data) {
var security = this.value;
- console.log('selected WiFi security: ' + security);
if (security === 'None') {
$('#input_wifi_password').textinput('disable');
function wifiEventReceived(event) {
if (event.type !== WS_EVENT_TYPE.WIFI) return;
console.log('WiFi event received: [' + event.name + ', ' + event.value + ']');
- if (event.name === 'enabled' && event.value === true) {
- wifiToggleOn();
- } else if (event.name === 'enabled' && event.value === false) {
- wifiToggleOff();
- }
}
function wifiClearKnownList() {
- console.log('Clear known WiFi network list');
$('#listview_network_known').html('');
}
function wifiClearAvailableList() {
- console.log('Clear available WiFi network list');
$('#listview_network_available').html('');
}
function wifiScan(adapter) {
+ if (wifiScanInProgress) return;
+
console.log('Start wifi scan');
/* clear the network list with new scan */
wifiClearKnownList();
wifiClearAvailableList();
+ showSpinner(false, 'Scanning...');
+ wifiScanInProgress = true;
+ $('#toggle_wifi').slider('disable');
+ $('#toggle_wifi').slider('refresh');
adapter.scan(function(networks) {
- console.log('found ' + networks.length + ' networks');
+ hideSpinner();
+ wifiScanInProgress = false;
+ $('#toggle_wifi').slider('enable');
+ $('#toggle_wifi').slider('refresh');
+ console.log('found ' + networks.length + ' wifi networks');
for (var i = 0; i < networks.length; i++) {
var network = networks[i];
- console.log('network ssid: ' + network.ssid);
- console.log('network connected: ' + network.connected);
- wifiUpdateNetwork(network);
+ if (network.ssid && network.ssid !== '') {
+ console.log('Skipping hidden network - ' + network.address);
+ wifiUpdateNetwork(network);
+ }
}
}, function(e) {
+ hideSpinner();
+ wifiScanInProgress = false;
+ $('#toggle_wifi').slider('enable');
+ $('#toggle_wifi').slider('refresh');
showMsg('Error', 'Cannot scan: ' + e);
- })
+ });
+}
+
+function wifiSync(adapter, success_cb, error_cb) {
+ if (wifiScanInProgress) return;
+
+ console.log('Start wifi sync');
+ /* clear the network list with new scan */
+ wifiClearKnownList();
+ wifiClearAvailableList();
+
+ wifiScanInProgress = true;
+ $('#toggle_wifi').slider('disable');
+ $('#toggle_wifi').slider('refresh');
+ adapter.scan(function(networks) {
+ hideSpinner();
+ wifiScanInProgress = false;
+ $('#toggle_wifi').slider('enable');
+ $('#toggle_wifi').slider('refresh');
+ console.log('found ' + networks.length + ' wifi networks');
+ for (var i = 0; i < networks.length; i++) {
+ var network = networks[i];
+ if (network.ssid && network.ssid !== '') {
+ wifiUpdateNetwork(network);
+ }
+ }
+ success_cb();
+ }, function(e) {
+ wifiScanInProgress = false;
+ $('#toggle_wifi').slider('enable');
+ $('#toggle_wifi').slider('refresh');
+ error_cb(e);
+ });
}
function wifiRefreshList() {
}
function wifiAppendToKnownList(network) {
- console.log('Append to known network list - ' + network.ssid);
- if ($('#listview_network_known').find(jqId(network.ssid)).length != 0) return;
+ if ($('#listview_network_known').find(jqId(network.id)).length != 0) return;
var parent = '#listview_network_known';
wifiConstructNetworkElement(parent, network);
wifiRefreshList();
}
-function wifiRemoveFromKnownList(network_ssid) {
+function wifiRemoveFromKnownList(network_id) {
var removeThis = $('#listview_network_known li').filter(function() {
- return $(this).find(jqId(network_ssid)).length === 1;
+ return $(this).find(jqId(network_id)).length === 1;
});
if (removeThis.length !== 0) {
- console.log('Remove from known network list - ' + network_ssid);
removeThis.remove();
wifiRefreshList();
}
}
function wifiAppendToAvailableList(network) {
- console.log('Append to available list - ' + network.ssid);
- if ($('#listview_network_available').find(jqId(network.ssid)).length != 0) return;
+ if ($('#listview_network_available').find(jqId(network.id)).length != 0) return;
var parent = '#listview_network_available';
wifiConstructNetworkElement(parent, network);
});
if (removeThis.length !== 0) {
- console.log('Remove from available list: ' + network_ssid);
removeThis.remove();
wifiRefreshList();
}
}
+function getSignalStrengthStr(strength) {
+ var signal_strength = 'unknown';
+ if (strength > 0 && strength <= 20) {
+ strength = 'very poor';
+ } else if (strength > 20 && strength <= 40) {
+ signal_strength = 'poor';
+ } else if (strength > 40 && strength <= 70) {
+ signal_strength = 'average';
+ } else if (strength > 70 && strength <= 90) {
+ signal_strength = 'good';
+ } else if (strength > 90 && strength <= 100) {
+ signal_strength = 'excellent';
+ }
+ return signal_strength;
+}
+
function wifiConstructNetworkElement(parent, network) {
- var html = '<li data-icon="false"><a href="#" id="' + jqId(network.ssid).replace('#', '') + '">';
+ var html = '<li data-icon="false"><a href="#" id="' + jqId(network.id).replace('#', '') + '">';
html += '<div class="network-ssid">' + network.ssid + '</div>';
+ html += '<div class="network-encryption">Encryption: ' + network.encryption + '</div>';
+ html += '<div class="network-strength">Signal: ' + getSignalStrengthStr(network.strength) + '</div>';
html += '<div class="network-status"></div>';
html += '<div data-role="button" class="network-action-button ui-li-aside" data-inline="true"></div>';
html += '</a></li>';
$(parent).append(html).trigger('create');
/* store network object in the element so we can reference it later */
- $(jqId(network.ssid)).data('network-object', network);
+ $(jqId(network.id)).data('network-object', network);
- $(jqId(network.ssid)).on('click', function() {
- localStorage.setItem('wifi_network_id', network.ssid);
+ $(jqId(network.id)).on('click', function() {
+ localStorage.setItem('wifi_network_id', network.id);
$.mobile.changePage('#page_wifi_detail');
});
- $(jqId(network.ssid)).find('div.network-action-button').on('click', function(e) {
+ $(jqId(network.id)).find('div.network-action-button').on('click', function(e) {
var parent = $(this).parent().attr('id');
- console.log('network action button clicked');
/*
* prevent the click event to propagate up
return;
}
+ if (!network.connected && network.encryption !== 'none') {
+ /* Encryption based connection not supported now */
+ showMsg('Error', 'Only open networks are supported');
+ return;
+ }
+
if (!network.connected) {
createPopupDialog(false, false, 'Connect to network', network.ssid, 'Connect', 'Cancel', function() {
console.log('WiFi connect to network: ' + network.ssid);
showSpinner(false, 'Connecting...');
- adapter.connectNetwork(network.ssid, null, null, function() {
+ adapter.connectNetwork(network.id, null, null, function() {
/* success */
- hideSpinner();
- network.connected = true;
-
- /* changing from disconnected to connected */
- wifiUpdateNetwork(network);
+ wifiSync(adapter, function() {
+ hideSpinner();
+ }, function(e) {
+ /* changing from disconnected to connected */
+ hideSpinner();
+ network.connected = true;
+ wifiUpdateNetwork(network);
+ })
}, function(e) {
/* error */
hideSpinner();
} else {
console.log('Wifi disconnect from network: ' + network.ssid);
showSpinner(false, 'Disconnecting...');
- adapter.disconnectNetwork(network.ssid, function() {
+ adapter.disconnectNetwork(network.id, function() {
/* success */
- hideSpinner();
- network.connected = false;
+ wifiSync(adapter, function() {
+ hideSpinner();
+ }, function(e) {
+ /* changing from connected to disconnected */
+ hideSpinner();
+ network.connected = false;
+ wifiUpdateNetwork(network);
+ })
$('#button_wifi_disconnect').remove();
-
- /* changing from connected to disconnected */
- wifiUpdateNetwork(network);
}, function(e) {
/* error */
hideSpinner();
showMsg('Error', 'Network disconnect failed: ' + e);
/* Something is wrong, remove from connected list */
- wifiRemoveFromKnownList(network.ssid);
+ wifiRemoveFromKnownList(network.id);
});
}
});
}
function wifiUpdateNetwork(network) {
- console.log('Constructing or updating WiFi network');
-
/* reposition device if it's connected or disconnected */
if (network.connected) {
- wifiRemoveFromAvailableList(network.ssid);
+ wifiRemoveFromAvailableList(network.id);
wifiAppendToKnownList(network);
} else {
- wifiRemoveFromKnownList(network.ssid);
+ wifiRemoveFromKnownList(network.id);
wifiAppendToAvailableList(network);
}
function wifiUpdateNetworkButton(network) {
if (network.connected) {
- $(jqId(network.ssid)).find('div.network-action-button').find('span').text('Disconnect');
+ $(jqId(network.id)).find('div.network-action-button').find('span').text('Disconnect');
} else {
- $(jqId(network.ssid)).find('div.network-action-button').find('span').text('Connect');
+ $(jqId(network.id)).find('div.network-action-button').find('span').text('Connect');
}
}
function wifiUpdateConnectionStatus(network) {
var status = 'disconnected';
if (network.connected) {
- $(jqId(network.ssid)).addClass('network-connected');
+ $(jqId(network.id)).addClass('network-connected');
status = 'connected';
} else {
status = 'disconnected';
- $(jqId(network.ssid)).removeClass('network-connected');
+ $(jqId(network.id)).removeClass('network-connected');
}
wifiUpdateConnectionStatusText(network, status);
}
function wifiUpdateConnectionStatusText(network, status) {
- $(jqId(network.ssid)).find('div.network-status').text(status);
+ $(jqId(network.id)).find('div.network-status').text(status);
}
function wifiConstructDetailPanel(network) {
if (network.connected) status_connected = 'Yes';
$('#page_wifi_detail_content').html('');
- var html = '<ul data-role="listview" id="listview_wifi_detail" data-inset="true" ' + 'class="network-list ui-listview">';
- html += '<li id="wifi_detail_ssid"><h2>SSID: ' + network.ssid + '</h2></li>';
- html += '<li id="wifi_detail_connected"><h2>Connected: ' + status_connected + '</h2></li>';
+ var html = '<ul data-role="listview" id="listview_network_detail" data-inset="true" ' + 'class="network-list ui-listview">';
+ html += '<li id="network_detail_ssid"><h2>SSID: ' + network.ssid + '</h2></li>';
+ html += '<li id="network_detail_encryption"><h2>Encryption: ' + network.encryption + '</h2></li>';
+ html += '<li id="network_detail_strength"><h2>Signal Strength: ' + network.strength + '</h2></li>';
+ html += '<li id="network_detail_connected"><h2>Connected: ' + status_connected + '</h2></li>';
+ if (network.connected) {
+ html += '<li id="network_detail_ip_address"><h2>IP Address: ' + network.ipAddress + '</h2></li>';
+ html += '<li id="network_detail_gateway"><h2>Gateway: ' + network.gateway + '</h2></li>';
+ html += '<li id="network_detail_netmask"><h2>Netmask: ' + network.netmask + '</h2></li>';
+ }
html += '</ul>';
$('#page_wifi_detail_content').append(html).trigger('create');
createPopupDialog(false, false, 'Disconnect from network', network.ssid, 'Disconnect', 'Cancel', function() {
showSpinner(false, 'Disconnecting...');
- adapter.disconnectNetwork(network.ssid, function() {
+ adapter.disconnectNetwork(network.id, function() {
/* success */
hideSpinner();
network.connected = false;
showMsg('Error', 'Network disconnect failed: ' + e);
/* Something is wrong, remove from connected list */
- wifiRemoveFromKnownList(network.ssid);
+ wifiRemoveFromKnownList(network.id);
});
});
});
}
function wifiToggleOn() {
- $('#wifi_networks').show();
- $('#toggle_wifi').val('on').slider('refresh');
+ setTimeout(function() {
+ $('#wifi_networks').show();
+ $('#toggle_wifi').val('on').slider('refresh');
+ }, 100);
}
function wifiToggleOff() {
- $('#wifi_networks').hide();
- $('#toggle_wifi').val('off').slider('refresh');
+ setTimeout(function() {
+ $('#wifi_networks').hide();
+ $('#toggle_wifi').val('off').slider('refresh');
+ }, 100);
}
\ No newline at end of file
if (id == undefined) return null;
/* replace colons and spaces with dash for jquery ids */
- return '#' + id.replace(/:| /g, '-');
+ return '#' + id.replace(/:| |\//g, '-');
}
function showMsg(title, message) {
if (title == 'Error') {
console.error(message);
+ if (message.indexOf(ERROR_SETTINGSD_DISCONNECTED) >= 0) {
+ createPopupDialog(false, false, ERROR_SETTINGSD_DISCONNECTED, 'Reconnect?', 'OK', 'Cancel', function() {
+ console.log('Reconnecting to settings daemon...');
+ wsAPI.reconnect();
+ });
+ return;
+ }
} else {
console.log(message);
}
/* Dummy backend for faking websocket daemon */
var dummyBackend = false;
+var ERROR_SETTINGSD_DISCONNECTED = 'Settings daemon is not connected';
+
var WS_REQUEST_TYPE = {
WIFI: "wifi",
BLUETOOTH: "bluetooth",
this.socketUrl = 'ws://localhost:16000/';
this.socketProtocol = 'http-only';
+ this.timeouttime = 15000;
this.methodIdx = 0;
this.methodCalls = [];
for (var i = 0; i < 100; i++) {
this.start = function() {
me.timeout = setTimeout(function() {
if (me.errorCB !== undefined) {
- me.errorCB('\"' + me.name + '\" method timed out after ' + self.timeouttime + 'ms');
+ me.errorCB('\"' + me.name + '\" method timed out after ' + self.timeouttime + ' ms');
}
me.finish();
}, self.timeouttime);
self.successCB();
};
- self.socket.onclose = function() {
+ self.socket.onclose = function(code, reason, remote) {
self.connected = false;
- console.log('websocket closed');
+ console.log('websocket closed - ' + reason);
if (dummyBackend) {
/* fake the connection for dummy backend */
return;
}
- self.errorCB('Disconnected from settings daemon');
+ self.errorCB(reason);
};
self.socket.onerror = function(e) {
- console.log('web socket error: ', e.data);
-
if (dummyBackend) {
/* ignore websocket error */
return;
};
self.socket.onmessage = function(e) {
- self.receive(e.data);
+ receive(e.data);
};
} else {
console.log('Websockets not supported');
}
}
+ function reconnect() {
+ if (this.connected) return;
+
+ setTimeout(function() {
+ connect(self.socketUrl, self.socketProtocol, self.successCB, self.errorCB);
+ }, 1000);
+ }
+
function send(msg, success_cb, error_cb) {
if (!this.connected) {
- if (errorCB !== undefined) {
- errorCB('Settings daemon is not connected');
+ if (error_cb !== undefined) {
+ error_cb(ERROR_SETTINGSD_DISCONNECTED);
}
return;
}
function receive(msg) {
var self = this;
- var event;
+ var response;
try {
console.log("Received json msg: " + msg);
- event = JSON.parse(msg);
+ response = JSON.parse(msg);
} catch (e) {
- self.iErrorCB('GARBAGE MESSAGE: ' + msg);
+ console.error('Garbage message: ' + msg);
return;
}
- if ((event === undefined) || (event.type === undefined) || (event.name === undefined)) {
- self.iErrorCB('BADLY FORMED MESSAGE: ' + msg);
+ if ((response === undefined) || (response.type === undefined) || (response.transactionid === undefined)) {
+ console.error('Badly formed message: ' + msg);
return;
} else {
- if (event.type === 'methodReply') {
+ if (response.type === 'event') {
+ console.log('new event: ' + response.name + ', ' + response.data);
+ self.fireSevent(response.name, response.value);
+ } else {
var calls = this.methodCalls;
for (var i = 0; i < calls.length; i++) {
var call = calls[i];
- if (call && (!call.done) && (call.transactionid === event.transactionid)) {
+ if (call && (!call.done) && (call.transactionid === response.transactionid)) {
call.finish();
- if (event.error !== undefined) {
- call.errorCB(event.error);
- }
- if (event.data !== undefined && call.successCB !== undefined) {
- call.successCB(event.data);
+ console.log('response matched');
+ if (response.result !== 'succeeded' && response.reason !== undefined && call.errorCB !== undefined) {
+ console.log('error - ' + response.reason);
+ call.errorCB(response.reason);
+ } else if (call.successCB !== undefined) {
+ if (response.value !== undefined) {
+ call.successCB(response.value);
+ } else {
+ call.successCB();
+ }
}
return;
}
}
- } else if (event.type === 'event') {
- self.fireSevent(event.name, event.data);
}
}
}
function sendRequest(request_type, request_name, request_args, success_cb, error_cb) {
var msg = {
'type': request_type,
- 'name': request_name,
'transactionid': generateTransactionId(),
- 'data': request_args
+ 'name': request_name,
+ 'value': request_args
};
send(msg, success_cb, error_cb);
if (msg.error !== undefined) {
call.errorCB(msg.error);
}
- if (msg.data !== undefined && call.successCB && call.errorCB !== undefined) {
- var replyDelay = 0;
-
+ if (msg.value !== undefined && call.successCB && call.errorCB !== undefined) {
switch (msg.type) {
case WS_REQUEST_TYPE.WIFI:
- if (msg.name === 'isEnabled') {
+ if (msg.name === 'is_enabled') {
/* default to enabled */
- var results = {
- 'isEnabled': true
- };
- replyMsg = JSON.stringify(results);
- } else if (msg.name === 'enable') {
- if (msg.data === true) {
- fireEvent(WS_EVENT_TYPE.WIFI, 'enabled', true);
- } else {
- fireEvent(WS_EVENT_TYPE.WIFI, 'enabled', false);
- }
+ var result = true;
+ console.log('is_enabled response ' + result);
+ call.successCB(result);
+ return;
+ } else if (msg.name === 'enable' && msg.value === true) {
+ call.successCB();
+ return;
+ } else if (msg.name === 'enable' && msg.value === false) {
+ call.successCB();
+ return;
} else if (msg.name === 'scan') {
- var results = {
- "services" : [
- [
- "/net/connman/service/ethernet_0010f32f5a70_cable",
- {
- }
- ],
- [
- "/net/connman/service/wifi_c8f733acdf96_3558364737_managed_psk",
- {
- }
- ],
- [
- "/net/connman/service/wifi_c8f733acdf96_446f75636865626167_managed_psk",
- {
- "Type" : "wifi",
- "Security" : [
- "psk"
- ],
- "State" : "idle",
- "Strength" : 50,
- "Favorite" : false,
- "Immutable" : false,
- "AutoConnect" : false,
- "Name" : "Foo",
- "BSSID" : "21:ef:30:b9:ad:86",
- "MaxRate" : 54000000,
- "Frequency" : 2417,
- "EncryptionMode" : "aes",
- "Ethernet" : {
- "Method" : "auto",
- "Interface" : "wlp1s0",
- "Address" : "E8:F2:33:AC:DF:96",
- "MTU" : 1500
- },
- "IPv4" : {
- },
- "IPv4.Configuration" : {
- "Method" : "dhcp"
- },
- "IPv6" : {
- },
- "IPv6.Configuration" : {
- "Method" : "auto",
- "Privacy" : "disabled"
- },
- "Nameservers" : [
- ],
- "Nameservers.Configuration" : [
- ],
- "Timeservers" : [
- ],
- "Timeservers.Configuration" : [
- ],
- "Domains" : [
- ],
- "Domains.Configuration" : [
- ],
- "Proxy" : {
- },
- "Proxy.Configuration" : {
- },
- "Provider" : {
- }
- }
- ],
- [
- "/net/connman/service/wifi_c8f733acdf96_536563757265446f75636865626167_managed_psk",
- {
- }
- ]
- ]
- }
+ var results = [
+ [
+ ["/net/connman/service/ethernet_0010f32f5a70_cable",
+ {}],
+ ["/net/connman/service/wifi_c8f733acdf96_3558364737_managed_psk",
+ {
+ "Type": "wifi",
+ "Security": ["psk"],
+ "State": "ready",
+ "Strength": 50,
+ "Favorite": false,
+ "Immutable": false,
+ "AutoConnect": false,
+ "Name": "Access Point 1",
+ "BSSID": "11:5d:49:88:3d:20",
+ "MaxRate": 54000000,
+ "Frequency": 2417,
+ "EncryptionMode": "aes",
+ "Ethernet": {
+ "Method": "auto",
+ "Interface": "wlp1s0",
+ "Address": "B2:D3:55:66:44:22",
+ "MTU": 1500
+ },
+ "IPv4": {
+ "Address": "192.168.1.20",
+ "Gateway": "192.168.1.1",
+ "Method": "dhcp",
+ "Netmask": "255.255.255.0"
+ },
+ "IPv4.Configuration": {
+ "Method": "dhcp"
+ },
+ "IPv6": {},
+ "IPv6.Configuration": {
+ "Method": "auto",
+ "Privacy": "disabled"
+ },
+ "Nameservers": [],
+ "Nameservers.Configuration": [],
+ "Timeservers": [],
+ "Timeservers.Configuration": [],
+ "Domains": [],
+ "Domains.Configuration": [],
+ "Proxy": {},
+ "Proxy.Configuration": {},
+ "Provider": {}
+ }],
+ ["/net/connman/service/wifi_c8f733acdf96_446f75636865626167_managed_psk",
+ {
+ "Type": "wifi",
+ "Security": ["psk"],
+ "State": "idle",
+ "Strength": 50,
+ "Favorite": false,
+ "Immutable": false,
+ "AutoConnect": false,
+ "Name": "Access Point 2",
+ "BSSID": "21:ef:30:b9:ad:86",
+ "MaxRate": 54000000,
+ "Frequency": 2417,
+ "EncryptionMode": "aes",
+ "Ethernet": {
+ "Method": "auto",
+ "Interface": "wlp1s0",
+ "Address": "E8:F2:33:AC:DF:96",
+ "MTU": 1500
+ },
+ "IPv4": {},
+ "IPv4.Configuration": {
+ "Method": "dhcp"
+ },
+ "IPv6": {},
+ "IPv6.Configuration": {
+ "Method": "auto",
+ "Privacy": "disabled"
+ },
+ "Nameservers": [],
+ "Nameservers.Configuration": [],
+ "Timeservers": [],
+ "Timeservers.Configuration": [],
+ "Domains": [],
+ "Domains.Configuration": [],
+ "Proxy": {},
+ "Proxy.Configuration": {},
+ "Provider": {}
+ }],
+ ["/net/connman/service/wifi_c8f733acdf96_536563757265446f75636865626167_managed_psk",
+ {
+ "Type": "wifi",
+ "Security": ["psk"],
+ "State": "idle",
+ "Strength": 50,
+ "Favorite": false,
+ "Immutable": false,
+ "AutoConnect": false,
+ "Name": "Access Point 3",
+ "BSSID": "25:ad:44:b7:e3:66",
+ "MaxRate": 54000000,
+ "Frequency": 2417,
+ "EncryptionMode": "aes",
+ "Ethernet": {
+ "Method": "auto",
+ "Interface": "wlp1s0",
+ "Address": "A9:28:44:AD:FF:26",
+ "MTU": 1500
+ },
+ "IPv4": {},
+ "IPv4.Configuration": {
+ "Method": "dhcp"
+ },
+ "IPv6": {},
+ "IPv6.Configuration": {
+ "Method": "auto",
+ "Privacy": "disabled"
+ },
+ "Nameservers": [],
+ "Nameservers.Configuration": [],
+ "Timeservers": [],
+ "Timeservers.Configuration": [],
+ "Domains": [],
+ "Domains.Configuration": [],
+ "Proxy": {},
+ "Proxy.Configuration": {},
+ "Provider": {}
+ }]
+ ]
+ ];
replyMsg = JSON.stringify(results);
+ console.log('scan response ' + replyMsg);
/* simulate scan behavior */
- replyDelay = 2000;
- } else if (msg.name === 'connect') {
- replyMsg = msg.data;
- fireEvent(WS_EVENT_TYPE.WIFI, 'connecting', replyMsg);
setTimeout(function() {
- fireEvent(WS_EVENT_TYPE.WIFI, 'connected', replyMsg);
- }, 1000);
+ call.successCB(results);
+ }, 2000);
+ return;
+ } else if (msg.name === 'connect') {
+ call.successCB();
+ return;
} else if (msg.name === 'disconnect') {
- replyMsg = msg.data;
- fireEvent(WS_EVENT_TYPE.WIFI, 'disconnecting', replyMsg);
- setTimeout(function() {
- fireEvent(WS_EVENT_TYPE.WIFI, 'disconnected', replyMsg);
- }, 1000);
+ call.successCB();
+ return;
} else {
- call.errorCB('Unsupported request name: ' + msg.name);
+ call.errorCB('Unsupported request: ' + msg.name + ', ' + msg.value);
return;
}
break;
case WS_REQUEST_TYPE.BLUETOOTH:
- if (msg.name === 'enable') {
- fireEvent(WS_EVENT_TYPE.BLUETOOTH, 'enabled', true);
- } else if (msg.name === 'disable') {
- fireEvent(WS_EVENT_TYPE.BLUETOOTH, 'enabled', false);
+ if (msg.name === 'enable' && msg.value === true) {
+ call.successCB();
+ return;
+ } else if (msg.name === 'enable' && msg.value === false) {
+ call.successCB();
+ return;
} else {
- call.errorCB('Unsupported request name: ' + msg.name);
+ call.errorCB('Unsupported request: ' + msg.name + ', ' + msg.value);
return;
}
break;
case WS_REQUEST_TYPE.DATETIME:
+ if (msg.name === 'is_time_updates_auto' && msg.value !== undefined) {
+ /* default to manual */
+ var result = false;
+ console.log('is_time_updates_auto response ' + result);
+ call.successCB(result);
+ return;
+ } else if (msg.name === 'is_timezone_updates_auto' && msg.value !== undefined) {
+ /* default to manual */
+ var result = false;
+ console.log('is_timezone_updates_auto response ' + result);
+ call.successCB(result);
+ return;
+ } else if (msg.name === 'time' && msg.value !== undefined) {
+ call.successCB();
+ return;
+ } else if (msg.name === 'timezone' && msg.value !== undefined) {
+ call.successCB();
+ return;
+ } else if (msg.name === 'time_updates' && msg.value !== undefined) {
+ call.successCB();
+ return;
+ } else if (msg.name === 'timezone_updates' && msg.value !== undefined) {
+ call.successCB();
+ return;
+ } else {
+ call.errorCB('Unsupported request: ' + msg.name + ', ' + msg.value);
+ return;
+ }
break;
case WS_REQUEST_TYPE.DISPLAY:
case WS_REQUEST_TYPE.SOUND:
call.errorCB('Invalid request type: ' + msg.type);
return;
}
- setTimeout(function() {
- call.successCB(replyMsg);
- }, replyDelay);
}
return;
}
return {
connect: connect,
+ reconnect: reconnect,
sendRequest: sendRequest,
subscribeEvents: subscribeEvents
}
+* Thu Oct 03 2013 Jimmy Huang <jimmy.huang@intel.com> accepted/tizen/20130918.214652@278671f
+- New release of SettingsApp
+ - Bumped version to 0.0.2
+ - Fixes TIVI-1788 - Setting error: Setting daemon is not connected
+ - Added runtime dependency on settingsd
+ - Fixed a bug where hidden network is still showing
+ - Various fixes date and time settings
+ - Added support for automatic time and timezone updates
+ - Add support for is_time_update_enabled and is_timezone_update_enabled requests
+ - Switch to text input instead of time and date input since the picker is broken
+ - Added time and date string validator
+ - Fixes clock not syncing right when moving out of focus
+ - Updated dummy backend
+ - Fixed a bug where GUI doesn't allow you to disconnect from encrypted networks
+ - Display ip address and other connected information
+ - Fixed a bug where toggle changes triggers recursive callbacks
+ - Cleaning up debug logs and error messages
+ - Fixed a bug where previous scan is not canceled when page is loaded
+ - Display wifi network encryption and signal strength
+ - Display error when trying to connect to encrypted network since it's not implemented
+ - Updated wifi scan handling code and added some more dummy data
+ - Ask user to reconnect to settings daemon if it is disconnected
+ - Disable wifi toggle button when scanning
+ - Show an error message for disconnecting from websocket
+
+
* Thu Sep 19 2013 Jimmy Huang <jimmy.huang@intel.com>
- Uninstall widget when doing rpm uninstall
Name: Settings
Summary: A HTML5 based app for system settings
-Version: 0.0.1
+Version: 0.0.2
Release: 1
Group: Applications/Web Applications
License: Apache-2.0
Source0: %{name}-%{version}.tar.bz2
BuildRequires: zip
BuildRequires: desktop-file-utils
-Requires: wrt-installer
Requires: bluetooth-frwk-core
Requires: bluetooth-frwk-service
+Requires: settingsd
+Requires: wrt-installer
%description
A HTML5 based app for system settings like WiFi, Bluetooth
projects / profile / ivi / SettingsApp.git / commitdiff