) newValue);
mBearerMulti.setSummary(bearer);
} else if (KEY_MVNO_TYPE.equals(key)) {
final String mvno = mvnoDescription((String) newValue);
if (mvno == null) {
return false;
}
mMvnoType.setValue((String) newValue);
mMvnoType.setSummary(mvno);
mMvnoMatchData.setSummary(checkNull(mMvnoMatchData.getText()));
} else if (KEY_PASSWORD.equals(key)) {
mPassword.setSummary(starify(newValue != null ? String.valueOf(newValue) : ""));
} else if (KEY_CARRIER_ENABLED.equals(key)) {
// do nothing
} else {
preference.setSummary(checkNull(newValue != null ? String.valueOf(newValue) : null));
}
return true;
}
@Override
public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
super.onCreateOptionsMenu(menu, inflater);
// If it's a new APN, then cancel will delete the new entry in onPause
if (!mNewApn && !mReadOnlyApn) {
menu.add(0, MENU_DELETE, 0, R.string.menu_delete)
.setIcon(R.drawable.ic_delete);
}
menu.add(0, MENU_SAVE, 0, R.string.menu_save)
.setIcon(android.R.drawable.ic_menu_save);
menu.add(0, MENU_CANCEL, 0, R.string.menu_cancel)
.setIcon(android.R.drawable.ic_menu_close_clear_cancel);
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
switch (item.getItemId()) {
case MENU_DELETE:
deleteApn();
finish();
return true;
case MENU_SAVE:
if (validateAndSaveApnData()) {
finish();
}
return true;
case MENU_CANCEL:
finish();
return true;
default:
return super.onOptionsItemSelected(item);
}
}
@Override
public void onViewCreated(View view, Bundle savedInstanceState) {
super.onViewCreated(view, savedInstanceState);
view.setOnKeyListener(this);
view.setFocusableInTouchMode(true);
view.requestFocus();
}
/**
* Try to save the apn data when pressed the back button. An error message will be displayed if
* the apn data is invalid.
*
* TODO(b/77339593): Try to keep the same behavior between back button and up navigate button.
* We will save the valid apn data to the database when pressed the back button, but discard all
* user changed when pressed the up navigate button.
*/
@Override
public boolean onKey(View v, int keyCode, KeyEvent event) {
if (event.getAction() != KeyEvent.ACTION_DOWN) return false;
switch (keyCode) {
case KeyEvent.KEYCODE_BACK: {
if (validateAndSaveApnData()) {
finish();
}
return true;
}
}
return false;
}
/**
* Add key, value to {@code cv} and compare the value against the value at index in
* {@link #mApnData}.
*
*
* The key, value will not add to {@code cv} if value is null.
*
* @return true if values are different. {@code assumeDiff} indicates if values can be assumed
* different in which case no comparison is needed.
*/
boolean setStringValueAndCheckIfDiff(
ContentValues cv, String key, String value, boolean assumeDiff, int index) {
final String valueFromLocalCache = mApnData.getString(index);
if (VDBG) {
Log.d(TAG, "setStringValueAndCheckIfDiff: assumeDiff: " + assumeDiff
+ " key: " + key
+ " value: '" + value
+ "' valueFromDb: '" + valueFromLocalCache + "'");
}
final boolean isDiff = assumeDiff
|| !((TextUtils.isEmpty(value) && TextUtils.isEmpty(valueFromLocalCache))
|| (value != null && value.equals(valueFromLocalCache)));
if (isDiff && value != null) {
cv.put(key, value);
}
return isDiff;
}
/**
* Add key, value to {@code cv} and compare the value against the value at index in
* {@link #mApnData}.
*
* @return true if values are different. {@code assumeDiff} indicates if values can be assumed
* different in which case no comparison is needed.
*/
boolean setIntValueAndCheckIfDiff(
ContentValues cv, String key, int value, boolean assumeDiff, int index) {
final Integer valueFromLocalCache = mApnData.getInteger(index);
if (VDBG) {
Log.d(TAG, "setIntValueAndCheckIfDiff: assumeDiff: " + assumeDiff
+ " key: " + key
+ " value: '" + value
+ "' valueFromDb: '" + valueFromLocalCache + "'");
}
final boolean isDiff = assumeDiff || value != valueFromLocalCache;
if (isDiff) {
cv.put(key, value);
}
return isDiff;
}
/**
* Validates the apn data and save it to the database if it's valid.
*
*
* A dialog with error message will be displayed if the APN data is invalid.
*
* @return true if there is no error
*/
@VisibleForTesting
boolean validateAndSaveApnData() {
// Nothing to do if it's a read only APN
if (mReadOnlyApn) {
return true;
}
final String name = checkNotSet(mName.getText());
final String apn = checkNotSet(mApn.getText());
final String mcc = checkNotSet(mMcc.getText());
final String mnc = checkNotSet(mMnc.getText());
final String errorMsg = validateApnData();
if (errorMsg != null) {
showError();
return false;
}
final ContentValues values = new ContentValues();
// call update() if it's a new APN. If not, check if any field differs from the db value;
// if any diff is found update() should be called
boolean callUpdate = mNewApn;
callUpdate = setStringValueAndCheckIfDiff(values,
Telephony.Carriers.NAME,
name,
callUpdate,
NAME_INDEX);
callUpdate = setStringValueAndCheckIfDiff(values,
Telephony.Carriers.APN,
apn,
callUpdate,
APN_INDEX);
callUpdate = setStringValueAndCheckIfDiff(values,
Telephony.Carriers.PROXY,
checkNotSet(mProxy.getText()),
callUpdate,
PROXY_INDEX);
callUpdate = setStringValueAndCheckIfDiff(values,
Telephony.Carriers.PORT,
checkNotSet(mPort.getText()),
callUpdate,
PORT_INDEX);
callUpdate = setStringValueAndCheckIfDiff(values,
Telephony.Carriers.MMSPROXY,
checkNotSet(mMmsProxy.getText()),
callUpdate,
MMSPROXY_INDEX);
callUpdate = setStringValueAndCheckIfDiff(values,
Telephony.Carriers.MMSPORT,
checkNotSet(mMmsPort.getText()),
callUpdate,
MMSPORT_INDEX);
callUpdate = setStringValueAndCheckIfDiff(values,
Telephony.Carriers.USER,
checkNotSet(mUser.getText()),
callUpdate,
USER_INDEX);
callUpdate = setStringValueAndCheckIfDiff(values,
Telephony.Carriers.SERVER,
checkNotSet(mServer.getText()),
callUpdate,
SERVER_INDEX);
callUpdate = setStringValueAndCheckIfDiff(values,
Telephony.Carriers.PASSWORD,
checkNotSet(mPassword.getText()),
callUpdate,
PASSWORD_INDEX);
callUpdate = setStringValueAndCheckIfDiff(values,
Telephony.Carriers.MMSC,
checkNotSet(mMmsc.getText()),
callUpdate,
MMSC_INDEX);
final String authVal = mAuthType.getValue();
if (authVal != null) {
callUpdate = setIntValueAndCheckIfDiff(values,
Telephony.Carriers.AUTH_TYPE,
Integer.parseInt(authVal),
callUpdate,
AUTH_TYPE_INDEX);
}
callUpdate = setStringValueAndCheckIfDiff(values,
Telephony.Carriers.PROTOCOL,
checkNotSet(mProtocol.getValue()),
callUpdate,
PROTOCOL_INDEX);
callUpdate = setStringValueAndCheckIfDiff(values,
Telephony.Carriers.ROAMING_PROTOCOL,
checkNotSet(mRoamingProtocol.getValue()),
callUpdate,
ROAMING_PROTOCOL_INDEX);
callUpdate = setStringValueAndCheckIfDiff(values,
Telephony.Carriers.TYPE,
checkNotSet(getUserEnteredApnType()),
callUpdate,
TYPE_INDEX);
callUpdate = setStringValueAndCheckIfDiff(values,
Telephony.Carriers.MCC,
mcc,
callUpdate,
MCC_INDEX);
callUpdate = setStringValueAndCheckIfDiff(values,
Telephony.Carriers.MNC,
mnc,
callUpdate,
MNC_INDEX);
values.put(Telephony.Carriers.NUMERIC, mcc + mnc);
if (mCurMnc != null && mCurMcc != null) {
if (mCurMnc.equals(mnc) && mCurMcc.equals(mcc)) {
values.put(Telephony.Carriers.CURRENT, 1);
}
}
final Set bearerSet = mBearerMulti.getValues();
int bearerBitmask = 0;
for (String bearer : bearerSet) {
if (Integer.parseInt(bearer) == 0) {
bearerBitmask = 0;
break;
} else {
bearerBitmask |= getBitmaskForTech(Integer.parseInt(bearer));
}
}
callUpdate = setIntValueAndCheckIfDiff(values,
Telephony.Carriers.BEARER_BITMASK,
bearerBitmask,
callUpdate,
BEARER_BITMASK_INDEX);
int bearerVal;
if (bearerBitmask == 0 || mBearerInitialVal == 0) {
bearerVal = 0;
} else if (bitmaskHasTech(bearerBitmask, mBearerInitialVal)) {
bearerVal = mBearerInitialVal;
} else {
// bearer field was being used but bitmask has changed now and does not include the
// initial bearer value -- setting bearer to 0 but maybe better behavior is to choose a
// random tech from the new bitmask??
bearerVal = 0;
}
callUpdate = setIntValueAndCheckIfDiff(values,
Telephony.Carriers.BEARER,
bearerVal,
callUpdate,
BEARER_INDEX);
callUpdate = setStringValueAndCheckIfDiff(values,
Telephony.Carriers.MVNO_TYPE,
checkNotSet(mMvnoType.getValue()),
callUpdate,
MVNO_TYPE_INDEX);
callUpdate = setStringValueAndCheckIfDiff(values,
Telephony.Carriers.MVNO_MATCH_DATA,
checkNotSet(mMvnoMatchData.getText()),
callUpdate,
MVNO_MATCH_DATA_INDEX);
callUpdate = setIntValueAndCheckIfDiff(values,
Telephony.Carriers.CARRIER_ENABLED,
mCarrierEnabled.isChecked() ? 1 : 0,
callUpdate,
CARRIER_ENABLED_INDEX);
values.put(Telephony.Carriers.EDITED_STATUS, Telephony.Carriers.USER_EDITED);
if (callUpdate) {
final Uri uri = mApnData.getUri() == null ? mCarrierUri : mApnData.getUri();
updateApnDataToDatabase(uri, values);
} else {
if (VDBG) Log.d(TAG, "validateAndSaveApnData: not calling update()");
}
return true;
}
private void updateApnDataToDatabase(Uri uri, ContentValues values) {
ThreadUtils.postOnBackgroundThread(() -> {
if (uri.equals(mCarrierUri)) {
// Add a new apn to the database
final Uri newUri = getContentResolver().insert(mCarrierUri, values);
if (newUri == null) {
Log.e(TAG, "Can't add a new apn to database " + mCarrierUri);
}
} else {
// Update the existing apn
getContentResolver().update(
uri, values, null /* where */, null /* selection Args */);
}
});
}
/**
* Validates whether the apn data is valid.
*
* @return An error message if the apn data is invalid, otherwise return null.
*/
@VisibleForTesting
String validateApnData() {
String errorMsg = null;
final String name = checkNotSet(mName.getText());
final String apn = checkNotSet(mApn.getText());
final String mcc = checkNotSet(mMcc.getText());
final String mnc = checkNotSet(mMnc.getText());
if (TextUtils.isEmpty(name)) {
errorMsg = getResources().getString(R.string.error_name_empty);
} else if (TextUtils.isEmpty(apn)) {
errorMsg = getResources().getString(R.string.error_apn_empty);
} else if (mcc == null || mcc.length() != 3) {
errorMsg = getResources().getString(R.string.error_mcc_not3);
} else if ((mnc == null || (mnc.length() & 0xFFFE) != 2)) {
errorMsg = getResources().getString(R.string.error_mnc_not23);
}
if (errorMsg == null) {
// if carrier does not allow editing certain apn types, make sure type does not include
// those
if (!ArrayUtils.isEmpty(mReadOnlyApnTypes)
&& apnTypesMatch(mReadOnlyApnTypes, getUserEnteredApnType())) {
final StringBuilder stringBuilder = new StringBuilder();
for (String type : mReadOnlyApnTypes) {
stringBuilder.append(type).append(", ");
Log.d(TAG, "validateApnData: appending type: " + type);
}
// remove last ", "
if (stringBuilder.length() >= 2) {
stringBuilder.delete(stringBuilder.length() - 2, stringBuilder.length());
}
errorMsg = String.format(getResources().getString(R.string.error_adding_apn_type),
stringBuilder);
}
}
return errorMsg;
}
@VisibleForTesting
void showError() {
ErrorDialog.showError(this);
}
private void deleteApn() {
if (mApnData.getUri() != null) {
getContentResolver().delete(mApnData.getUri(), null, null);
mApnData = new ApnData(sProjection.length);
}
}
private String starify(String value) {
if (value == null || value.length() == 0) {
return sNotSet;
} else {
final char[] password = new char[value.length()];
for (int i = 0; i < password.length; i++) {
password[i] = '*';
}
return new String(password);
}
}
/**
* Returns {@link #sNotSet} if the given string {@code value} is null or empty. The string
* {@link #sNotSet} typically used as the default display when an entry in the preference is
* null or empty.
*/
private String checkNull(String value) {
return TextUtils.isEmpty(value) ? sNotSet : value;
}
/**
* Returns null if the given string {@code value} equals to {@link #sNotSet}. This method
* should be used when convert a string value from preference to database.
*/
private String checkNotSet(String value) {
return sNotSet.equals(value) ? null : value;
}
@VisibleForTesting
String getUserEnteredApnType() {
// if user has not specified a type, map it to "ALL APN TYPES THAT ARE NOT READ-ONLY"
// but if user enter empty type, map it just for default
String userEnteredApnType = mApnType.getText();
if (userEnteredApnType != null) userEnteredApnType = userEnteredApnType.trim();
if ((TextUtils.isEmpty(userEnteredApnType)
|| APN_TYPE_ALL.equals(userEnteredApnType))) {
userEnteredApnType = getEditableApnType(APN_TYPES);
}
Log.d(TAG, "getUserEnteredApnType: changed apn type to editable apn types: "
+ userEnteredApnType);
return userEnteredApnType;
}
private String getEditableApnType(String[] apnTypeList) {
final StringBuilder editableApnTypes = new StringBuilder();
final List readOnlyApnTypes = Arrays.asList(mReadOnlyApnTypes);
boolean first = true;
for (String apnType : apnTypeList) {
// add APN type if it is not read-only and is not wild-cardable
if (!readOnlyApnTypes.contains(apnType)
&& !apnType.equals(APN_TYPE_IA)
&& !apnType.equals(APN_TYPE_EMERGENCY)
&& !apnType.equals(APN_TYPE_MCX)) {
if (first) {
first = false;
} else {
editableApnTypes.append(",");
}
editableApnTypes.append(apnType);
}
}
return editableApnTypes.toString();
}
private void initApnEditorUi() {
addPreferencesFromResource(R.xml.apn_editor);
sNotSet = getResources().getString(R.string.apn_not_set);
mName = (EditTextPreference) findPreference("apn_name");
mApn = (EditTextPreference) findPreference("apn_apn");
mProxy = (EditTextPreference) findPreference("apn_http_proxy");
mPort = (EditTextPreference) findPreference("apn_http_port");
mUser = (EditTextPreference) findPreference("apn_user");
mServer = (EditTextPreference) findPreference("apn_server");
mPassword = (EditTextPreference) findPreference(KEY_PASSWORD);
mMmsProxy = (EditTextPreference) findPreference("apn_mms_proxy");
mMmsPort = (EditTextPreference) findPreference("apn_mms_port");
mMmsc = (EditTextPreference) findPreference("apn_mmsc");
mMcc = (EditTextPreference) findPreference("apn_mcc");
mMnc = (EditTextPreference) findPreference("apn_mnc");
mApnType = (EditTextPreference) findPreference("apn_type");
mAuthType = (ListPreference) findPreference(KEY_AUTH_TYPE);
mProtocol = (ListPreference) findPreference(KEY_PROTOCOL);
mRoamingProtocol = (ListPreference) findPreference(KEY_ROAMING_PROTOCOL);
mCarrierEnabled = (SwitchPreference) findPreference(KEY_CARRIER_ENABLED);
mBearerMulti = (MultiSelectListPreference) findPreference(KEY_BEARER_MULTI);
mMvnoType = (ListPreference) findPreference(KEY_MVNO_TYPE);
mMvnoMatchData = (EditTextPreference) findPreference("mvno_match_data");
}
private void getCarrierCustomizedConfig() {
mReadOnlyApn = false;
mReadOnlyApnTypes = null;
mReadOnlyApnFields = null;
final CarrierConfigManager configManager =
getSystemService(CarrierConfigManager.class);
if (configManager != null) {
final PersistableBundle b = configManager.getConfigForSubId(mSubId);
if (b != null) {
mReadOnlyApnTypes = b.getStringArray(
CarrierConfigManager.KEY_READ_ONLY_APN_TYPES_STRING_ARRAY);
if (!ArrayUtils.isEmpty(mReadOnlyApnTypes)) {
Log.d(TAG,
"onCreate: read only APN type: " + Arrays.toString(mReadOnlyApnTypes));
}
mReadOnlyApnFields = b.getStringArray(
CarrierConfigManager.KEY_READ_ONLY_APN_FIELDS_STRING_ARRAY);
mDefaultApnTypes = b.getStringArray(
CarrierConfigManager.KEY_APN_SETTINGS_DEFAULT_APN_TYPES_STRING_ARRAY);
if (!ArrayUtils.isEmpty(mDefaultApnTypes)) {
Log.d(TAG, "onCreate: default apn types: " + Arrays.toString(mDefaultApnTypes));
}
mDefaultApnProtocol = b.getString(
CarrierConfigManager.Apn.KEY_SETTINGS_DEFAULT_PROTOCOL_STRING);
if (!TextUtils.isEmpty(mDefaultApnProtocol)) {
Log.d(TAG, "onCreate: default apn protocol: " + mDefaultApnProtocol);
}
mDefaultApnRoamingProtocol = b.getString(
CarrierConfigManager.Apn.KEY_SETTINGS_DEFAULT_ROAMING_PROTOCOL_STRING);
if (!TextUtils.isEmpty(mDefaultApnRoamingProtocol)) {
Log.d(TAG, "onCreate: default apn roaming protocol: "
+ mDefaultApnRoamingProtocol);
}
}
}
}
private void setCarrierCustomizedConfigToUi() {
if (TextUtils.isEmpty(mApnType.getText()) && !ArrayUtils.isEmpty(mDefaultApnTypes)) {
String value = getEditableApnType(mDefaultApnTypes);
mApnType.setText(value);
mApnType.setSummary(value);
}
String protocol = protocolDescription(mDefaultApnProtocol, mProtocol);
if (TextUtils.isEmpty(mProtocol.getValue()) && !TextUtils.isEmpty(protocol)) {
mProtocol.setValue(mDefaultApnProtocol);
mProtocol.setSummary(protocol);
}
String roamingProtocol = protocolDescription(mDefaultApnRoamingProtocol, mRoamingProtocol);
if (TextUtils.isEmpty(mRoamingProtocol.getValue()) && !TextUtils.isEmpty(roamingProtocol)) {
mRoamingProtocol.setValue(mDefaultApnRoamingProtocol);
mRoamingProtocol.setSummary(roamingProtocol);
}
}
public static class ErrorDialog extends InstrumentedDialogFragment {
public static void showError(ApnEditor editor) {
final ErrorDialog dialog = new ErrorDialog();
dialog.setTargetFragment(editor, 0);
dialog.show(editor.getFragmentManager(), "error");
}
@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
final String msg = ((ApnEditor) getTargetFragment()).validateApnData();
return new AlertDialog.Builder(getContext())
.setTitle(R.string.error_title)
.setPositiveButton(android.R.string.ok, null)
.setMessage(msg)
.create();
}
@Override
public int getMetricsCategory() {
return SettingsEnums.DIALOG_APN_EDITOR_ERROR;
}
}
@VisibleForTesting
ApnData getApnDataFromUri(Uri uri) {
ApnData apnData = null;
try (Cursor cursor = getContentResolver().query(
uri,
sProjection,
null /* selection */,
null /* selectionArgs */,
null /* sortOrder */)) {
if (cursor != null) {
cursor.moveToFirst();
apnData = new ApnData(uri, cursor);
}
}
if (apnData == null) {
Log.d(TAG, "Can't get apnData from Uri " + uri);
}
return apnData;
}
@VisibleForTesting
static class ApnData {
/**
* The uri correspond to a database row of the apn data. This should be null if the apn
* is not in the database.
*/
Uri mUri;
/** Each element correspond to a column of the database row. */
Object[] mData;
ApnData(int numberOfField) {
mData = new Object[numberOfField];
}
ApnData(Uri uri, Cursor cursor) {
mUri = uri;
mData = new Object[cursor.getColumnCount()];
for (int i = 0; i < mData.length; i++) {
switch (cursor.getType(i)) {
case Cursor.FIELD_TYPE_FLOAT:
mData[i] = cursor.getFloat(i);
break;
case Cursor.FIELD_TYPE_INTEGER:
mData[i] = cursor.getInt(i);
break;
case Cursor.FIELD_TYPE_STRING:
mData[i] = cursor.getString(i);
break;
case Cursor.FIELD_TYPE_BLOB:
mData[i] = cursor.getBlob(i);
break;
default:
mData[i] = null;
}
}
}
Uri getUri() {
return mUri;
}
void setUri(Uri uri) {
mUri = uri;
}
Integer getInteger(int index) {
return (Integer) mData[index];
}
Integer getInteger(int index, Integer defaultValue) {
final Integer val = getInteger(index);
return val == null ? defaultValue : val;
}
String getString(int index) {
return (String) mData[index];
}
}
private static int getBitmaskForTech(int radioTech) {
if (radioTech >= 1) {
return (1 << (radioTech - 1));
}
return 0;
}
private static boolean bitmaskHasTech(int bearerBitmask, int radioTech) {
if (bearerBitmask == 0) {
return true;
} else if (radioTech >= 1) {
return ((bearerBitmask & (1 << (radioTech - 1))) != 0);
}
return false;
}
}