b38dea0597
Share Gaia assets and adapters, keep private profiles and development documents local, and update both public READMEs.
856 lines
25 KiB
JavaScript
856 lines
25 KiB
JavaScript
'use strict';
|
|
/* global _ */
|
|
/* global Cache */
|
|
/* global ConfirmDialog */
|
|
/* global Contacts */
|
|
/* global ContactsBTExport */
|
|
/* global ContactsExporter */
|
|
/* global ContactsSDExport */
|
|
/* global ContactsSIMExport */
|
|
/* global IccHandler */
|
|
/* global LazyLoader */
|
|
/* global navigationStack */
|
|
/* global Rest */
|
|
/* global SimContactsImporter */
|
|
/* global SimDomGenerator */
|
|
/* global utils */
|
|
/* global VCFReader */
|
|
/* global ContactsService */
|
|
/* global ExtServices */
|
|
/* global Loader */
|
|
/* global BulkDelete */
|
|
/* global ICE */
|
|
/* global Telemetry */
|
|
|
|
var contacts = window.contacts || {};
|
|
|
|
/***
|
|
This class handles all the activity regarding
|
|
the settings screen for contacts
|
|
**/
|
|
contacts.Settings = (function() {
|
|
|
|
var navigationHandler,
|
|
importSettingsHeader,
|
|
orderCheckBox,
|
|
orderItem,
|
|
orderByLastName,
|
|
setICEButton,
|
|
importSettingsPanel,
|
|
importSettingsTitle,
|
|
importContacts,
|
|
exportContacts,
|
|
importOptions,
|
|
exportOptions,
|
|
importLiveOption,
|
|
importGmailOption,
|
|
importSDOption,
|
|
exportSDOption,
|
|
newOrderByLastName = null,
|
|
PENDING_LOGOUT_KEY = 'pendingLogout',
|
|
bulkDeleteButton;
|
|
|
|
var EXPORT_TRANSITION_LEVEL = 2, DELETE_TRANSITION_LEVEL = 1;
|
|
|
|
// Initialise the settings screen (components, listeners ...)
|
|
var init = function initialize() {
|
|
// Create the DOM for our SIM cards and listen to any changes
|
|
IccHandler.init(new SimDomGenerator(), contacts.Settings.cardStateChanged);
|
|
|
|
initContainers();
|
|
// To avoid any race condition we listen for online events once
|
|
// containers have been initialized
|
|
window.addEventListener('online', checkOnline);
|
|
window.addEventListener('offline', checkOnline);
|
|
|
|
// Subscribe to events related to change state in the sd card
|
|
utils.sdcard.subscribeToChanges('check_sdcard', function(value) {
|
|
updateStorageOptions(utils.sdcard.checkStorageCard());
|
|
});
|
|
|
|
window.addEventListener('timeformatchange', updateTimestamps);
|
|
};
|
|
|
|
var hideSettings = function hideSettings() {
|
|
contacts.Settings.close();
|
|
};
|
|
|
|
// Get the different values that we will show in the app
|
|
var getData = function getData() {
|
|
var config = utils.cookie.load();
|
|
var order = config ? config.order : false;
|
|
orderByLastName = order;
|
|
newOrderByLastName = null;
|
|
updateOrderingUI();
|
|
};
|
|
|
|
var updateOrderingUI = function updateOrderingUI() {
|
|
var value = newOrderByLastName === null ? orderByLastName :
|
|
newOrderByLastName;
|
|
orderCheckBox.checked = value;
|
|
orderCheckBox.setAttribute('aria-checked', value);
|
|
};
|
|
|
|
var updateImportTitle = function updateImportTitle(l10nString) {
|
|
importSettingsTitle.setAttribute('data-l10n-id', l10nString);
|
|
};
|
|
|
|
// Initialises variables and listener for the UI
|
|
var initContainers = function initContainers() {
|
|
orderItem = document.getElementById('settingsOrder');
|
|
orderCheckBox = orderItem.querySelector('[name="order.lastname"]');
|
|
orderCheckBox.addEventListener('change', onOrderingChange.bind(this));
|
|
// Creating a navigation handler from this view
|
|
navigationHandler = new navigationStack('view-settings');
|
|
|
|
// Init panel & elements for caching them
|
|
importSettingsPanel = document.getElementById('import-settings');
|
|
importSDOption = document.getElementById('import-sd-option');
|
|
exportSDOption = document.getElementById('export-sd-option');
|
|
importSettingsTitle = document.getElementById('import-settings-title');
|
|
importLiveOption = document.getElementById('import-live-option');
|
|
importGmailOption = document.getElementById('import-gmail-option');
|
|
|
|
// ICE view
|
|
setICEButton = document.getElementById('set-ice');
|
|
|
|
/*
|
|
* Adding listeners
|
|
*/
|
|
|
|
document.getElementById('settings-close').addEventListener(
|
|
'click',
|
|
hideSettings
|
|
);
|
|
// Listener for updating the timestamp based on extServices
|
|
window.addEventListener('message', function updateList(e) {
|
|
if (e.data.type === 'import_updated') {
|
|
updateTimestamps();
|
|
checkNoContacts();
|
|
}
|
|
});
|
|
|
|
// Navigation back
|
|
importSettingsHeader = document.getElementById('import-settings-header');
|
|
importSettingsHeader.addEventListener('action', importSettingsBackHandler);
|
|
|
|
// Handlers for the navigation through the panels
|
|
importContacts = document.getElementById('importContacts');
|
|
importContacts.firstElementChild.
|
|
addEventListener('click', importContactsHandler);
|
|
|
|
exportContacts = document.getElementById('exportContacts');
|
|
exportContacts.firstElementChild.
|
|
addEventListener('click', exportContactsHandler);
|
|
|
|
// Handlers for the actions related with EXPORT/IMPORT
|
|
importOptions = document.getElementById('import-options');
|
|
importOptions.addEventListener('click', importOptionsHandler);
|
|
|
|
exportOptions = document.getElementById('export-options');
|
|
exportOptions.addEventListener('click', exportOptionsHandler);
|
|
|
|
// ICE view
|
|
setICEButton.addEventListener('click', showICEScreen);
|
|
|
|
// Bulk delete
|
|
bulkDeleteButton = document.getElementById('bulkDelete');
|
|
bulkDeleteButton.addEventListener('click', bulkDeleteHandler);
|
|
};
|
|
|
|
// UI event handlers
|
|
function importSettingsBackHandler() {
|
|
navigationHandler.back(function navigateBackHandler() {
|
|
// Removing the previous assigned style for having
|
|
// a clean view
|
|
importSettingsPanel.classList.remove('export');
|
|
importSettingsPanel.classList.remove('import');
|
|
});
|
|
}
|
|
|
|
function importContactsHandler() {
|
|
// Hide elements for export and transition
|
|
LazyLoader.load(['/contacts/js/utilities/telemetry.js'], () => {
|
|
importSettingsPanel.classList.remove('export');
|
|
importSettingsPanel.classList.add('import');
|
|
updateImportTitle('importContactsTitle');
|
|
navigationHandler.go('import-settings', 'right-left');
|
|
});
|
|
}
|
|
|
|
function exportContactsHandler() {
|
|
// Hide elements for import and transition
|
|
LazyLoader.load(['/contacts/js/export/contacts_exporter.js'], loadSearch);
|
|
|
|
function loadSearch() {
|
|
Loader.view('search', function() {
|
|
importSettingsPanel.classList.remove('import');
|
|
importSettingsPanel.classList.add('export');
|
|
updateImportTitle('exportContactsTitle');
|
|
navigationHandler.go('import-settings', 'right-left');
|
|
});
|
|
}
|
|
}
|
|
|
|
function showICEScreen(cb) {
|
|
LazyLoader.load([
|
|
'/contacts/js/utilities/ice_data.js',
|
|
'/contacts/js/views/ice_settings.js',
|
|
'/shared/js/contacts/utilities/ice_store.js'], function(){
|
|
ICE.refresh();
|
|
navigationHandler.go('ice-settings', 'right-left');
|
|
if (typeof cb === 'function') {
|
|
cb();
|
|
}
|
|
});
|
|
}
|
|
|
|
// Given an event, select wich should be the targeted
|
|
// import/export source
|
|
function getSource(e) {
|
|
var source = e.target.parentNode.dataset.source;
|
|
// Check special cases
|
|
if (source && source.indexOf('-') != -1) {
|
|
source = source.substr(0, source.indexOf('-'));
|
|
}
|
|
return source;
|
|
}
|
|
|
|
function logImportUsage(name) {
|
|
return Telemetry.logImportUsage(name);
|
|
}
|
|
|
|
function importOptionsHandler(e) {
|
|
/* jshint validthis:true */
|
|
|
|
var source = getSource(e);
|
|
switch (source) {
|
|
case 'sim':
|
|
var iccId = e.target.parentNode.dataset.iccid;
|
|
window.setTimeout(requireSimImport.bind(this,
|
|
onSimImport.bind(this, iccId)), 0);
|
|
break;
|
|
case 'sd':
|
|
window.setTimeout(requireOverlay.bind(this, onSdImport), 0);
|
|
break;
|
|
case 'gmail':
|
|
ExtServices.onContactsImported = logImportUsage.bind(null, 'gmail');
|
|
ExtServices.importGmail();
|
|
break;
|
|
case 'live':
|
|
ExtServices.onContactsImported = logImportUsage.bind(null, 'live');
|
|
ExtServices.importLive();
|
|
break;
|
|
}
|
|
}
|
|
|
|
var bulkDeleteHandler = function bulkDeleteHandler() {
|
|
LazyLoader.load(
|
|
[
|
|
'/contacts/js/contacts_bulk_delete.js',
|
|
'/contacts/js/contacts_remover.js'
|
|
],
|
|
function() {
|
|
Loader.view('search', function() {
|
|
contacts.List.selectFromList(_('DeleteTitle'),
|
|
function onSelectedContacts(promise, done) {
|
|
BulkDelete.performDelete(promise, done);
|
|
},
|
|
null,
|
|
navigationHandler,
|
|
{
|
|
transitionLevel: DELETE_TRANSITION_LEVEL
|
|
}
|
|
);
|
|
});
|
|
}
|
|
);
|
|
};
|
|
|
|
function exportOptionsHandler(e) {
|
|
var source = getSource(e);
|
|
switch (source) {
|
|
case 'sim':
|
|
var iccId = e.target.parentNode.dataset.iccid;
|
|
LazyLoader.load(['/contacts/js/export/sim.js'],
|
|
function() {
|
|
doExport(new ContactsSIMExport(IccHandler.getIccById(iccId)));
|
|
}
|
|
);
|
|
break;
|
|
case 'sd':
|
|
LazyLoader.load(
|
|
[
|
|
'/shared/js/device_storage/get_storage_if_available.js',
|
|
'/shared/js/device_storage/get_unused_filename.js',
|
|
'/shared/js/contact2vcard.js',
|
|
'/shared/js/setImmediate.js',
|
|
'/contacts/js/export/sd.js'
|
|
],
|
|
function() {
|
|
doExport(new ContactsSDExport());
|
|
}
|
|
);
|
|
break;
|
|
case 'bluetooth':
|
|
LazyLoader.load(
|
|
[
|
|
'/shared/js/device_storage/get_storage_if_available.js',
|
|
'/shared/js/device_storage/get_unused_filename.js',
|
|
'/shared/js/contact2vcard.js',
|
|
'/shared/js/setImmediate.js',
|
|
'/contacts/js/export/bt.js'
|
|
],
|
|
function() {
|
|
doExport(new ContactsBTExport());
|
|
}
|
|
);
|
|
break;
|
|
}
|
|
}
|
|
|
|
function doExport(strategy) {
|
|
// Launch the selection mode in the list, and then invoke
|
|
// the export with the selected strategy.
|
|
|
|
contacts.List.selectFromList(_('exportContactsAction'),
|
|
function onSelectedContacts(promise) {
|
|
// Resolve the promise, meanwhile show an overlay to
|
|
// warn the user of the ongoin operation, dismiss it
|
|
// once we have the result
|
|
requireOverlay(function _loaded() {
|
|
utils.overlay.show('preparing-contacts', null, 'spinner');
|
|
promise.onsuccess = function onSuccess(ids) {
|
|
// Once we start the export process we can exit from select mode
|
|
// This will have to evolve once export errors can be captured
|
|
contacts.List.exitSelectMode();
|
|
var exporter = new ContactsExporter(strategy);
|
|
exporter.init(ids, function onExporterReady() {
|
|
// Leave the contact exporter to deal with the overlay
|
|
exporter.start();
|
|
});
|
|
};
|
|
promise.onerror = function onError() {
|
|
contacts.List.exitSelectMode();
|
|
utils.overlay.hide();
|
|
};
|
|
});
|
|
},
|
|
null,
|
|
navigationHandler,
|
|
{
|
|
isDanger: false,
|
|
transitionLevel: EXPORT_TRANSITION_LEVEL
|
|
}
|
|
);
|
|
}
|
|
|
|
// Options checking & updating
|
|
|
|
var checkSIMCard = function checkSIMCard() {
|
|
var statuses = IccHandler.getStatus();
|
|
statuses.forEach(function onStatus(status) {
|
|
enableSIMOptions(status.iccId, status.cardState);
|
|
});
|
|
};
|
|
|
|
// Disables/Enables an option and show the error if needed
|
|
var updateOptionStatus =
|
|
function updateOptionStatus(domOption, disabled, error) {
|
|
if (domOption === null) {
|
|
return;
|
|
}
|
|
var optionButton = domOption.firstElementChild;
|
|
if (disabled) {
|
|
optionButton.setAttribute('disabled', 'disabled');
|
|
if (error) {
|
|
domOption.classList.add('error');
|
|
} else {
|
|
domOption.classList.remove('error');
|
|
}
|
|
} else {
|
|
optionButton.removeAttribute('disabled');
|
|
domOption.classList.remove('error');
|
|
}
|
|
};
|
|
|
|
// Disables/Enables the actions over the sim import functionality
|
|
var enableSIMOptions = function enableSIMOptions(iccId, cardState) {
|
|
var importSimOption = document.getElementById('import-sim-option-' + iccId);
|
|
var exportSimOption = document.getElementById('export-sim-option-' + iccId);
|
|
var disabled = (cardState !== 'ready' && cardState !== 'illegal');
|
|
updateOptionStatus(importSimOption, disabled, true);
|
|
updateOptionStatus(exportSimOption, disabled, true);
|
|
};
|
|
|
|
/**
|
|
* Disables/Enables the actions over the sdcard import/export functionality
|
|
* @param {Boolean} cardAvailable Whether functions should be enabled or not.
|
|
*/
|
|
var updateStorageOptions = function updateStorageOptions(cardAvailable) {
|
|
// Enable/Disable button and shows/hides error message
|
|
updateOptionStatus(importSDOption, !cardAvailable, true);
|
|
updateOptionStatus(exportSDOption, !cardAvailable, true);
|
|
|
|
var importSDErrorL10nId = null;
|
|
var exportSDErrorL10nId = null;
|
|
|
|
var cardShared = utils.sdcard.status === utils.sdcard.SHARED;
|
|
if (!cardAvailable) {
|
|
importSDErrorL10nId = 'noMemoryCardMsg';
|
|
exportSDErrorL10nId = 'noMemoryCardMsgExport';
|
|
|
|
if (cardShared) {
|
|
importSDErrorL10nId = exportSDErrorL10nId = 'memoryCardUMSEnabled';
|
|
}
|
|
}
|
|
|
|
// update the message
|
|
var importSDErrorNode = importSDOption.querySelector('p.error-message');
|
|
if (importSDErrorL10nId) {
|
|
importSDErrorNode.setAttribute('data-l10n-id', importSDErrorL10nId);
|
|
} else {
|
|
importSDErrorNode.removeAttribute('data-l10n-id');
|
|
importSDErrorNode.textContent = '';
|
|
}
|
|
|
|
var exportSDErrorNode = exportSDOption.querySelector('p');
|
|
if (exportSDErrorL10nId) {
|
|
exportSDErrorNode.setAttribute('data-l10n-id', exportSDErrorL10nId);
|
|
} else {
|
|
exportSDErrorNode.removeAttribute('data-l10n-id');
|
|
exportSDErrorNode.textContent = '';
|
|
}
|
|
|
|
};
|
|
|
|
/**
|
|
* Loads the overlay class before showing
|
|
*/
|
|
function requireOverlay(callback) {
|
|
Loader.utility('Overlay', callback);
|
|
}
|
|
|
|
/**
|
|
* Loads required libraries for sim import
|
|
*/
|
|
function requireSimImport(callback) {
|
|
var libraries = ['Overlay', 'Import_sim_contacts'];
|
|
var pending = libraries.length;
|
|
|
|
libraries.forEach(function onPending(library) {
|
|
Loader.utility(library, next);
|
|
});
|
|
|
|
function next() {
|
|
if (!(--pending)) {
|
|
callback();
|
|
}
|
|
}
|
|
}
|
|
|
|
function resetWait(wakeLock) {
|
|
Contacts.hideOverlay();
|
|
if (wakeLock) {
|
|
wakeLock.unlock();
|
|
}
|
|
}
|
|
|
|
// Listens for any change in the ordering preferences
|
|
var onOrderingChange = function onOrderingChange(evt) {
|
|
newOrderByLastName = orderCheckBox.checked;
|
|
updateOrderingUI();
|
|
};
|
|
|
|
// Import contacts from SIM card and updates ui
|
|
var onSimImport = function onSimImport(iccId, done) {
|
|
var icc = IccHandler.getIccById(iccId);
|
|
if (icc === null) {
|
|
return;
|
|
}
|
|
var progress = Contacts.showOverlay('simContacts-reading',
|
|
'activityBar');
|
|
|
|
var wakeLock = navigator.requestWakeLock('cpu');
|
|
|
|
var cancelled = false, contactsRead = false;
|
|
var importer = new SimContactsImporter(icc);
|
|
utils.overlay.showMenu();
|
|
utils.overlay.oncancel = function oncancel() {
|
|
cancelled = true;
|
|
importer.finish();
|
|
if (contactsRead) {
|
|
// A message about canceling will be displayed while the current chunk
|
|
// is being cooked
|
|
progress.setClass('activityBar');
|
|
utils.overlay.hideMenu();
|
|
progress.setHeaderMsg('messageCanceling');
|
|
} else {
|
|
importer.onfinish(); // Early return while reading contacts
|
|
}
|
|
};
|
|
var totalContactsToImport;
|
|
var importedContacts = 0;
|
|
// Delay for showing feedback to the user after importing
|
|
var DELAY_FEEDBACK = 200;
|
|
|
|
importer.onread = function import_read(n) {
|
|
contactsRead = true;
|
|
totalContactsToImport = n;
|
|
if (totalContactsToImport > 0) {
|
|
progress.setClass('progressBar');
|
|
progress.setHeaderMsg('simContacts-importing');
|
|
progress.setTotal(totalContactsToImport);
|
|
}
|
|
};
|
|
|
|
importer.onfinish = function import_finish(numDupsMerged) {
|
|
window.setTimeout(function onfinish_import() {
|
|
resetWait(wakeLock);
|
|
if (importedContacts > 0) {
|
|
var source = 'sim-' + iccId;
|
|
utils.misc.setTimestamp(source, function() {
|
|
// Once the timestamp is saved, update the list
|
|
updateTimestamps();
|
|
checkNoContacts();
|
|
});
|
|
}
|
|
if (!cancelled) {
|
|
utils.status.show({
|
|
id: 'simContacts-imported3',
|
|
args: {
|
|
n: importedContacts
|
|
}
|
|
},
|
|
!numDupsMerged ? null : {
|
|
id: 'contactsMerged',
|
|
args: {
|
|
numDups: numDupsMerged
|
|
}
|
|
});
|
|
} else {
|
|
logImportUsage('sim');
|
|
}
|
|
|
|
typeof done === 'function' && done();
|
|
|
|
}, DELAY_FEEDBACK);
|
|
|
|
importer.onfinish = null;
|
|
};
|
|
|
|
importer.onimported = function imported_contact() {
|
|
importedContacts++;
|
|
if (!cancelled) {
|
|
progress.update();
|
|
}
|
|
};
|
|
|
|
importer.onerror = function import_error() {
|
|
var cancel = {
|
|
title: 'cancel',
|
|
callback: function() {
|
|
ConfirmDialog.hide();
|
|
}
|
|
};
|
|
var retry = {
|
|
title: 'retry',
|
|
isRecommend: true,
|
|
callback: function() {
|
|
ConfirmDialog.hide();
|
|
// And now the action is reproduced one more time
|
|
window.setTimeout(requireSimImport.bind(this,
|
|
onSimImport.bind(this, iccId)), 0);
|
|
}
|
|
};
|
|
ConfirmDialog.show(null, 'simContacts-error', cancel, retry);
|
|
resetWait(wakeLock);
|
|
};
|
|
|
|
importer.start();
|
|
};
|
|
|
|
var onSdImport = function onSdImport(cb) {
|
|
var cancelled = false;
|
|
var importer = null;
|
|
var progress = Contacts.showOverlay(
|
|
'memoryCardContacts-importing',
|
|
'activityBar',
|
|
'infiniteProgress'
|
|
);
|
|
utils.overlay.showMenu();
|
|
utils.overlay.oncancel = function() {
|
|
cancelled = true;
|
|
importer ? importer.finish() : Contacts.hideOverlay();
|
|
};
|
|
var wakeLock = navigator.requestWakeLock('cpu');
|
|
|
|
var importedContacts = 0;
|
|
// Delay for showing feedback to the user after importing
|
|
var DELAY_FEEDBACK = 200;
|
|
|
|
utils.sdcard.retrieveFiles([
|
|
'text/vcard',
|
|
'text/x-vcard',
|
|
'text/directory;profile=vCard',
|
|
'text/directory'
|
|
], ['vcf', 'vcard'], function(err, fileArray) {
|
|
if (err) {
|
|
return import_error(err, cb);
|
|
}
|
|
|
|
if (cancelled) {
|
|
return;
|
|
}
|
|
|
|
if (fileArray.length) {
|
|
var promises = [];
|
|
fileArray.forEach(file => {
|
|
promises.push(utils.sdcard.getTextFromFile(file, onContacts));
|
|
});
|
|
Promise.all(promises).then(results => {
|
|
var numDupsMerged = results.reduce((sum, current) => {
|
|
return sum + current;
|
|
});
|
|
window.setTimeout(() => {
|
|
utils.misc.setTimestamp('sd', () => {
|
|
// Once the timestamp is saved, update the list
|
|
updateTimestamps();
|
|
checkNoContacts();
|
|
resetWait(wakeLock);
|
|
|
|
if (!cancelled) {
|
|
var msg1 = {
|
|
id: 'memoryCardContacts-imported3',
|
|
args: {
|
|
n: importedContacts
|
|
}
|
|
};
|
|
var msg2 = !numDupsMerged ? null : {
|
|
id: 'contactsMerged',
|
|
args: {
|
|
numDups: numDupsMerged
|
|
}
|
|
};
|
|
|
|
utils.status.show(msg1, msg2);
|
|
|
|
logImportUsage('sd');
|
|
|
|
if (typeof cb === 'function') {
|
|
cb();
|
|
}
|
|
}
|
|
});
|
|
}, DELAY_FEEDBACK);
|
|
}).catch(error => {
|
|
import_error(error);
|
|
});
|
|
} else {
|
|
import_error('No contacts were found.', cb);
|
|
}
|
|
});
|
|
|
|
function onContacts(text) {
|
|
if (cancelled) {
|
|
return Promise.reject();
|
|
}
|
|
return new Promise((resolve, reject) => {
|
|
importer = new VCFReader(text);
|
|
if (!text || !importer) {
|
|
var error = 'No contacts were found';
|
|
import_error(error);
|
|
reject(error);
|
|
return;
|
|
}
|
|
|
|
importer.onimported = imported_contact;
|
|
importer.onerror = error => {
|
|
import_error(error);
|
|
reject(error);
|
|
};
|
|
|
|
importer.process((unused, numDupsMerged) => {
|
|
if (cancelled) {
|
|
reject('Cancelled');
|
|
Contacts.hideOverlay();
|
|
return;
|
|
}
|
|
resolve(numDupsMerged);
|
|
});
|
|
});
|
|
}
|
|
|
|
function imported_contact() {
|
|
importedContacts++;
|
|
progress.update();
|
|
}
|
|
|
|
function import_error(e, cb) {
|
|
var cancel = {
|
|
title: 'cancel',
|
|
callback: function() {
|
|
ConfirmDialog.hide();
|
|
}
|
|
};
|
|
|
|
var retry = {
|
|
title: 'retry',
|
|
isRecommend: true,
|
|
callback: function() {
|
|
ConfirmDialog.hide();
|
|
// And now the action is reproduced one more time
|
|
window.setTimeout(requireOverlay.bind(this, onSdImport), 0);
|
|
}
|
|
};
|
|
ConfirmDialog.show(null, 'memoryCardContacts-error', cancel,
|
|
retry);
|
|
resetWait(wakeLock);
|
|
if (typeof cb === 'function') {
|
|
cb();
|
|
}
|
|
}
|
|
};
|
|
|
|
// Dismiss settings window and execute operations if values got modified
|
|
var close = function close() {
|
|
if (newOrderByLastName != null &&
|
|
newOrderByLastName != orderByLastName && contacts.List) {
|
|
contacts.List.setOrderByLastName(newOrderByLastName);
|
|
utils.cookie.update({order: newOrderByLastName});
|
|
Cache.evict();
|
|
// Force the reset of the dom, we know that we changed the order
|
|
contacts.List.load(null, true);
|
|
orderByLastName = newOrderByLastName;
|
|
}
|
|
|
|
Contacts.goBack();
|
|
};
|
|
|
|
var checkOnline = function() {
|
|
// Perform pending automatic logouts
|
|
window.setTimeout(automaticLogout, 0);
|
|
|
|
// Other import services settings
|
|
updateOptionStatus(importGmailOption, !navigator.onLine, true);
|
|
updateOptionStatus(importLiveOption, !navigator.onLine, true);
|
|
};
|
|
|
|
var checkNoContacts = function checkNoContacts() {
|
|
var exportButton = exportContacts.firstElementChild;
|
|
|
|
ContactsService.isEmpty(function(error, isEmpty) {
|
|
if (error) {
|
|
window.console.warn(
|
|
'Error while trying to know the contact number',
|
|
error
|
|
);
|
|
// In case of error is safer to leave enabled
|
|
exportButton.removeAttribute('disabled');
|
|
bulkDeleteButton.removeAttribute('disabled');
|
|
return;
|
|
}
|
|
if (isEmpty) {
|
|
exportButton.setAttribute('disabled', 'disabled');
|
|
bulkDeleteButton.setAttribute('disabled', 'disabled');
|
|
setICEButton.setAttribute('disabled', 'disabled');
|
|
} else {
|
|
exportButton.removeAttribute('disabled');
|
|
bulkDeleteButton.removeAttribute('disabled');
|
|
setICEButton.removeAttribute('disabled');
|
|
}
|
|
});
|
|
};
|
|
|
|
function saveStatus(data) {
|
|
window.asyncStorage.setItem(PENDING_LOGOUT_KEY, data);
|
|
}
|
|
|
|
function automaticLogout() {
|
|
if (navigator.offLine === true) {
|
|
return;
|
|
}
|
|
|
|
LazyLoader.load(['/shared/js/contacts/utilities/http_rest.js'],
|
|
function() {
|
|
window.asyncStorage.getItem(PENDING_LOGOUT_KEY, function(data) {
|
|
if (!data) {
|
|
return;
|
|
}
|
|
var services = Object.keys(data);
|
|
var numResponses = 0;
|
|
|
|
services.forEach(function(service) {
|
|
var url = data[service];
|
|
|
|
var callbacks = {
|
|
success: function logout_success() {
|
|
numResponses++;
|
|
window.console.log('Successfully logged out: ', service);
|
|
delete data[service];
|
|
if (numResponses === services.length) {
|
|
saveStatus(data);
|
|
}
|
|
},
|
|
error: function logout_error() {
|
|
numResponses++;
|
|
if (numResponses === services.length) {
|
|
saveStatus(data);
|
|
}
|
|
},
|
|
timeout: function logout_timeout() {
|
|
numResponses++;
|
|
if (numResponses === services.length) {
|
|
saveStatus(data);
|
|
}
|
|
}
|
|
};
|
|
Rest.get(url, callbacks);
|
|
});
|
|
});
|
|
});
|
|
}
|
|
|
|
var updateTimestamps = function updateTimestamps() {
|
|
// TODO Add the same functionality to 'EXPORT' methods when ready.
|
|
var importSources =
|
|
document.querySelectorAll('#import-options li[data-source]');
|
|
Array.prototype.forEach.call(importSources, function(node) {
|
|
utils.misc.getTimestamp(node.dataset.source,
|
|
function(time) {
|
|
var spanID = 'notImported';
|
|
if (time) {
|
|
spanID = 'imported';
|
|
var timeElement = node.querySelector('p > time');
|
|
timeElement.setAttribute('datetime',
|
|
(new Date(time)).toLocaleString());
|
|
timeElement.textContent = utils.time.pretty(time);
|
|
}
|
|
node.querySelector('p > span').setAttribute('data-l10n-id', spanID);
|
|
});
|
|
});
|
|
};
|
|
|
|
var refresh = function refresh() {
|
|
getData();
|
|
checkOnline();
|
|
checkSIMCard();
|
|
utils.sdcard.getStatus(function statusUpdated() {
|
|
updateStorageOptions(utils.sdcard.checkStorageCard());
|
|
});
|
|
updateTimestamps();
|
|
checkNoContacts();
|
|
};
|
|
|
|
return {
|
|
'init': init,
|
|
'close': close,
|
|
'refresh': refresh,
|
|
'cardStateChanged': checkSIMCard,
|
|
'updateTimestamps': updateTimestamps,
|
|
'showICEScreen' : showICEScreen,
|
|
get navigation() { return navigationHandler; },
|
|
'importFromSDCard': onSdImport,
|
|
'importFromSIMCard': onSimImport
|
|
};
|
|
})();
|