'use strict';
/* global SettingsHelper, BaseModule, LazyLoader */
(function() {
/**
* TelephonySettings sets voice privacy and roaming modes based on
* the users saved settings.
* @requires SettingsHelper
* @class TelephonySettings
*/
function TelephonySettings(core) {
this.started = false;
this.connections = Array.slice(core.mobileConnections || []);
}
BaseModule.create(TelephonySettings, {
name: 'TelephonySettings',
/**
* Initialzes all settings.
* @memberof TelephonySettings.prototype
*/
_start: function() {
// XXX: Deprecate SettingsHelper usage in system app
// and use this.readSetting instead.
return LazyLoader.load('shared/js/settings_helper.js').then(() => {
this.initVoicePrivacy();
this.initRoaming();
this.initCallerIdPreference();
this.initPreferredNetworkType();
});
},
/**
* Initializes voice privacy based on user setting.
*/
initVoicePrivacy: function() {
var defaultVoicePrivacySettings =
this.connections.map(function() { return false; });
var voicePrivacyHelper =
SettingsHelper('ril.voicePrivacy.enabled', defaultVoicePrivacySettings);
voicePrivacyHelper.get(function got_vp(values) {
this.connections.forEach(function vp_iterator(conn, index) {
var setReq = conn.setVoicePrivacyMode(values[index]);
setReq.onerror = function set_vpm_error() {
if (setReq.error.name === 'RequestNotSupported' ||
setReq.error.name === 'GenericFailure') {
console.log('Request not supported.');
} else {
console.error('Error setting voice privacy.');
}
};
});
}.bind(this));
},
/**
* Initializes roaming based on user setting.
*/
initRoaming: function() {
var defaultRoamingPreferences =
this.connections.map(function() { return 'any'; });
var roamingPreferenceHelper =
SettingsHelper('ril.roaming.preference', defaultRoamingPreferences);
roamingPreferenceHelper.get(function got_rp(values) {
this.connections.forEach(function rp_iterator(conn, index) {
var setReq = conn.setRoamingPreference(values[index]);
setReq.onerror = function set_vpm_error() {
if (setReq.error.name === 'RequestNotSupported' ||
setReq.error.name === 'GenericFailure') {
console.log('Request not supported.');
} else {
console.error('Error roaming preference.');
}
};
});
}.bind(this));
},
/**
* Initializes caller id restriction based on user setting.
*
* CLIR_DEFAULT: 0
* CLIR_INVOCATION: 1
* CLIR_SUPPRESSION: 2
*/
initCallerIdPreference: function() {
var callerIdPreferenceHelper = SettingsHelper('ril.clirMode', null);
var that = this;
callerIdPreferenceHelper.get(function got_cid(values) {
that.connections.forEach(function cid_iterator(conn, index) {
if (values && values[index] !== null) {
that._setCallerIdPreference(conn, values[index], function() {
that._syncCallerIdPreferenceWithCarrier(conn, index,
callerIdPreferenceHelper);
that._registerListenerForCallerIdPreference(conn, index,
callerIdPreferenceHelper);
});
} else {
that._registerListenerForCallerIdPreference(conn, index,
callerIdPreferenceHelper);
}
});
});
},
_registerListenerForCallerIdPreference: function(conn, index, helper) {
// register event handler for caller id preference change, but we should
// always query the real settings value from the carrier.
conn.addEventListener('clirmodechange', function onclirchanged(event) {
this._syncCallerIdPreferenceWithCarrier(conn, index, helper);
}.bind(this));
},
_syncCallerIdPreferenceWithCarrier: function(conn, index, helper) {
var that = this;
this._getCallerIdPreference(conn, function(realValue) {
helper.get(function got_cid(values) {
values = values || that.connections.map(function() {
return 0;
});
values[index] = realValue;
helper.set(values);
});
});
},
_getCallerIdPreference: function(conn, callback) {
var req = conn.getCallingLineIdRestriction();
req.onsuccess = req.onerror = function(event) {
var value = 0;
if (req.result) {
switch (req.result.m) {
case 1: // Permanently provisioned
case 3: // Temporary presentation disallowed
case 4: // Temporary presentation allowed
value = req.result.n;
break;
case 0: // Not Provisioned
case 2: // Unknown (network error, etc)
value = 0;
break;
default:
value = 0;
break;
}
}
if (callback) {
callback(value);
}
};
},
_setCallerIdPreference: function(conn, callerIdPreference, callback) {
if (!conn.setCallingLineIdRestriction) {
if (callback) {
callback();
}
return;
}
var doSet = function() {
var setReq = conn.setCallingLineIdRestriction(callerIdPreference);
setReq.onsuccess = function set_cid_success() {
if (callback) {
callback();
}
};
setReq.onerror = function set_cid_error() {
console.error('Error set caller id restriction.');
if (callback) {
callback();
}
};
};
// Waiting for voice connected
if (conn.voice && conn.voice.connected) {
doSet();
} else {
conn.addEventListener('voicechange', function onchange() {
if (conn.voice && conn.voice.connected) {
conn.removeEventListener('voicechange', onchange);
doSet();
}
});
}
},
/**
* Initialize preferred network type. If the default value is null, we
* should use the option that makes the device able to connect all supported
* netwrok types.
*/
initPreferredNetworkType: function() {
var preferredNetworkTypeHelper =
SettingsHelper('ril.radio.preferredNetworkType');
preferredNetworkTypeHelper.get(function got_pnt(values) {
if (!values) {
values = this._getDefaultPreferredNetworkTypes();
preferredNetworkTypeHelper.set(values);
} else if (typeof values == 'string') {
// do the migration
var tempDefault = this._getDefaultPreferredNetworkTypes();
tempDefault[0] = values;
values = tempDefault;
preferredNetworkTypeHelper.set(values);
}
this.connections.forEach(function pnt_iterator(conn, index) {
this._setDefaultPreferredNetworkType(conn, values[index]);
}, this);
}.bind(this));
},
_setDefaultPreferredNetworkType: function(conn, preferredNetworkType) {
var doSet = function() {
var setReq = conn.setPreferredNetworkType(preferredNetworkType);
setReq.onerror = function set_vpm_error() {
console.error('Error setting preferred network type: ' +
preferredNetworkType);
};
};
if (conn.radioState === 'enabled') {
doSet();
} else {
conn.addEventListener('radiostatechange', function onchange() {
if (conn.radioState === 'enabled') {
conn.removeEventListener('radiostatechange', onchange);
doSet();
}
});
}
},
/**
* Returns an array specifying the default preferred network types of all
* mobile connections.
*/
_getDefaultPreferredNetworkTypes: function() {
return this.connections.map(function(conn) {
return this._getDefaultPreferredNetworkType(conn.supportedNetworkTypes);
}, this);
},
/**
* Returns the default preferred network types based on the hardware
* supported network types.
*/
_getDefaultPreferredNetworkType: function(hwSupportedTypes) {
return ['lte', 'wcdma', 'gsm', 'cdma', 'evdo'].filter(function(type) {
return (hwSupportedTypes && hwSupportedTypes.indexOf(type) !== -1);
}).join('/');
}
});
}());