package com.android.phone;
import com.android.internal.telephony.CallForwardInfo;
import com.android.internal.telephony.CommandException;
import com.android.internal.telephony.CommandsInterface;
import com.android.internal.telephony.Phone;
import android.app.AlertDialog;
import android.content.Context;
import android.content.DialogInterface;
import android.content.res.TypedArray;
import android.os.AsyncResult;
import android.os.Handler;
import android.os.Message;
import android.os.PersistableBundle;
import android.telephony.CarrierConfigManager;
import android.telephony.PhoneNumberUtils;
import android.telephony.TelephonyManager;
import android.text.BidiFormatter;
import android.text.SpannableString;
import android.text.TextDirectionHeuristics;
import android.text.TextUtils;
import android.util.AttributeSet;
import android.util.Log;
import android.view.View;
import static com.android.phone.TimeConsumingPreferenceActivity.RESPONSE_ERROR;
import static com.android.phone.TimeConsumingPreferenceActivity.EXCEPTION_ERROR;
public class CallForwardEditPreference extends EditPhoneNumberPreference {
private static final String LOG_TAG = "CallForwardEditPreference";
private static final String SRC_TAGS[] = {"{0}"};
private CharSequence mSummaryOnTemplate;
/**
* Remembers which button was clicked by a user. If no button is clicked yet, this should have
* {@link DialogInterface#BUTTON_NEGATIVE}, meaning "cancel".
*
* TODO: consider removing this variable and having getButtonClicked() in
* EditPhoneNumberPreference instead.
*/
private int mButtonClicked;
private int mServiceClass;
private MyHandler mHandler = new MyHandler();
int reason;
private Phone mPhone;
CallForwardInfo callForwardInfo;
private TimeConsumingPreferenceListener mTcpListener;
// Should we replace CF queries containing an invalid number with "Voicemail"
private boolean mReplaceInvalidCFNumber = false;
public CallForwardEditPreference(Context context, AttributeSet attrs) {
super(context, attrs);
mSummaryOnTemplate = this.getSummaryOn();
TypedArray a = context.obtainStyledAttributes(attrs,
R.styleable.CallForwardEditPreference, 0, R.style.EditPhoneNumberPreference);
mServiceClass = a.getInt(R.styleable.CallForwardEditPreference_serviceClass,
CommandsInterface.SERVICE_CLASS_VOICE);
reason = a.getInt(R.styleable.CallForwardEditPreference_reason,
CommandsInterface.CF_REASON_UNCONDITIONAL);
a.recycle();
Log.d(LOG_TAG, "mServiceClass=" + mServiceClass + ", reason=" + reason);
}
public CallForwardEditPreference(Context context) {
this(context, null);
}
void init(TimeConsumingPreferenceListener listener, boolean skipReading, Phone phone,
boolean replaceInvalidCFNumber) {
mPhone = phone;
mTcpListener = listener;
mReplaceInvalidCFNumber = replaceInvalidCFNumber;
if (!skipReading) {
mPhone.getCallForwardingOption(reason,
mHandler.obtainMessage(MyHandler.MESSAGE_GET_CF,
// unused in this case
CommandsInterface.CF_ACTION_DISABLE,
MyHandler.MESSAGE_GET_CF, null));
if (mTcpListener != null) {
mTcpListener.onStarted(this, true);
}
}
}
@Override
protected void onBindDialogView(View view) {
// default the button clicked to be the cancel button.
mButtonClicked = DialogInterface.BUTTON_NEGATIVE;
super.onBindDialogView(view);
}
@Override
public void onClick(DialogInterface dialog, int which) {
super.onClick(dialog, which);
mButtonClicked = which;
}
@Override
protected void onDialogClosed(boolean positiveResult) {
super.onDialogClosed(positiveResult);
Log.d(LOG_TAG, "mButtonClicked=" + mButtonClicked + ", positiveResult=" + positiveResult);
// Ignore this event if the user clicked the cancel button, or if the dialog is dismissed
// without any button being pressed (back button press or click event outside the dialog).
if (this.mButtonClicked != DialogInterface.BUTTON_NEGATIVE) {
int action = (isToggled() || (mButtonClicked == DialogInterface.BUTTON_POSITIVE)) ?
CommandsInterface.CF_ACTION_REGISTRATION :
CommandsInterface.CF_ACTION_DISABLE;
int time = (reason != CommandsInterface.CF_REASON_NO_REPLY) ? 0 : 20;
final String number = getPhoneNumber();
Log.d(LOG_TAG, "callForwardInfo=" + callForwardInfo);
if (action == CommandsInterface.CF_ACTION_REGISTRATION
&& callForwardInfo != null
&& callForwardInfo.status == 1
&& number.equals(callForwardInfo.number)) {
// no change, do nothing
Log.d(LOG_TAG, "no change, do nothing");
} else {
// set to network
Log.d(LOG_TAG, "reason=" + reason + ", action=" + action
+ ", number=" + number);
// Display no forwarding number while we're waiting for
// confirmation
setSummaryOn("");
// the interface of Phone.setCallForwardingOption has error:
// should be action, reason...
mPhone.setCallForwardingOption(action,
reason,
number,
time,
mHandler.obtainMessage(MyHandler.MESSAGE_SET_CF,
action,
MyHandler.MESSAGE_SET_CF));
if (mTcpListener != null) {
mTcpListener.onStarted(this, false);
}
}
}
}
void handleCallForwardResult(CallForwardInfo cf) {
callForwardInfo = cf;
Log.d(LOG_TAG, "handleGetCFResponse done, callForwardInfo=" + callForwardInfo);
// In some cases, the network can send call forwarding URIs for voicemail that violate the
// 3gpp spec. This can cause us to receive "numbers" that are sequences of letters. In this
// case, we must detect these series of characters and replace them with "Voicemail".
// PhoneNumberUtils#formatNumber returns null if the number is not valid.
if (mReplaceInvalidCFNumber && (PhoneNumberUtils.formatNumber(callForwardInfo.number,
getCurrentCountryIso()) == null)) {
callForwardInfo.number = getContext().getString(R.string.voicemail);
Log.i(LOG_TAG, "handleGetCFResponse: Overridding CF number");
}
setToggled(callForwardInfo.status == 1);
boolean displayVoicemailNumber = false;
if (TextUtils.isEmpty(callForwardInfo.number)) {
PersistableBundle carrierConfig =
PhoneGlobals.getInstance().getCarrierConfigForSubId(mPhone.getSubId());
if (carrierConfig != null) {
displayVoicemailNumber = carrierConfig.getBoolean(CarrierConfigManager
.KEY_DISPLAY_VOICEMAIL_NUMBER_AS_DEFAULT_CALL_FORWARDING_NUMBER_BOOL);
Log.d(LOG_TAG, "display voicemail number as default");
}
}
String voicemailNumber = mPhone.getVoiceMailNumber();
setPhoneNumber(displayVoicemailNumber ? voicemailNumber : callForwardInfo.number);
}
private void updateSummaryText() {
if (isToggled()) {
final String number = getRawPhoneNumber();
if (number != null && number.length() > 0) {
// Wrap the number to preserve presentation in RTL languages.
String wrappedNumber = BidiFormatter.getInstance().unicodeWrap(
number, TextDirectionHeuristics.LTR);
String values[] = { wrappedNumber };
String summaryOn = String.valueOf(
TextUtils.replace(mSummaryOnTemplate, SRC_TAGS, values));
int start = summaryOn.indexOf(wrappedNumber);
SpannableString spannableSummaryOn = new SpannableString(summaryOn);
PhoneNumberUtils.addTtsSpan(spannableSummaryOn,
start, start + wrappedNumber.length());
setSummaryOn(spannableSummaryOn);
} else {
setSummaryOn(getContext().getString(R.string.sum_cfu_enabled_no_number));
}
}
}
/**
* @return The ISO 3166-1 two letters country code of the country the user is in based on the
* network location.
*/
private String getCurrentCountryIso() {
final TelephonyManager telephonyManager =
(TelephonyManager) getContext().getSystemService(Context.TELEPHONY_SERVICE);
if (telephonyManager == null) {
return "";
}
return telephonyManager.getNetworkCountryIso().toUpperCase();
}
// Message protocol:
// what: get vs. set
// arg1: action -- register vs. disable
// arg2: get vs. set for the preceding request
private class MyHandler extends Handler {
static final int MESSAGE_GET_CF = 0;
static final int MESSAGE_SET_CF = 1;
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case MESSAGE_GET_CF:
handleGetCFResponse(msg);
break;
case MESSAGE_SET_CF:
handleSetCFResponse(msg);
break;
}
}
private void handleGetCFResponse(Message msg) {
Log.d(LOG_TAG, "handleGetCFResponse: done");
mTcpListener.onFinished(CallForwardEditPreference.this, msg.arg2 != MESSAGE_SET_CF);
AsyncResult ar = (AsyncResult) msg.obj;
callForwardInfo = null;
if (ar.exception != null) {
Log.d(LOG_TAG, "handleGetCFResponse: ar.exception=" + ar.exception);
if (ar.exception instanceof CommandException) {
mTcpListener.onException(CallForwardEditPreference.this,
(CommandException) ar.exception);
} else {
// Most likely an ImsException and we can't handle it the same way as
// a CommandException. The best we can do is to handle the exception
// the same way as mTcpListener.onException() does when it is not of type
// FDN_CHECK_FAILURE.
mTcpListener.onError(CallForwardEditPreference.this, EXCEPTION_ERROR);
}
} else {
if (ar.userObj instanceof Throwable) {
mTcpListener.onError(CallForwardEditPreference.this, RESPONSE_ERROR);
}
CallForwardInfo cfInfoArray[] = (CallForwardInfo[]) ar.result;
if (cfInfoArray.length == 0) {
Log.d(LOG_TAG, "handleGetCFResponse: cfInfoArray.length==0");
setEnabled(false);
mTcpListener.onError(CallForwardEditPreference.this, RESPONSE_ERROR);
} else {
for (int i = 0, length = cfInfoArray.length; i < length; i++) {
Log.d(LOG_TAG, "handleGetCFResponse, cfInfoArray[" + i + "]="
+ cfInfoArray[i]);
if ((mServiceClass & cfInfoArray[i].serviceClass) != 0) {
// corresponding class
CallForwardInfo info = cfInfoArray[i];
handleCallForwardResult(info);
// Show an alert if we got a success response but
// with unexpected values.
// Currently only handle the fail-to-disable case
// since we haven't observed fail-to-enable.
if (msg.arg2 == MESSAGE_SET_CF &&
msg.arg1 == CommandsInterface.CF_ACTION_DISABLE &&
info.status == 1) {
// Skip showing error dialog since some operators return
// active status even if disable call forward succeeded.
// And they don't like the error dialog.
if (isSkipCFFailToDisableDialog()) {
Log.d(LOG_TAG, "Skipped Callforwarding fail-to-disable dialog");
continue;
}
CharSequence s;
switch (reason) {
case CommandsInterface.CF_REASON_BUSY:
s = getContext().getText(R.string.disable_cfb_forbidden);
break;
case CommandsInterface.CF_REASON_NO_REPLY:
s = getContext().getText(R.string.disable_cfnry_forbidden);
break;
default: // not reachable
s = getContext().getText(R.string.disable_cfnrc_forbidden);
}
AlertDialog.Builder builder = new AlertDialog.Builder(getContext());
builder.setNeutralButton(R.string.close_dialog, null);
builder.setTitle(getContext().getText(R.string.error_updating_title));
builder.setMessage(s);
builder.setCancelable(true);
builder.create().show();
}
}
}
}
}
// Now whether or not we got a new number, reset our enabled
// summary text since it may have been replaced by an empty
// placeholder.
updateSummaryText();
}
private void handleSetCFResponse(Message msg) {
AsyncResult ar = (AsyncResult) msg.obj;
if (ar.exception != null) {
Log.d(LOG_TAG, "handleSetCFResponse: ar.exception=" + ar.exception);
// setEnabled(false);
}
Log.d(LOG_TAG, "handleSetCFResponse: re get");
mPhone.getCallForwardingOption(reason,
obtainMessage(MESSAGE_GET_CF, msg.arg1, MESSAGE_SET_CF, ar.exception));
}
}
/*
* Get the config of whether skip showing CF fail-to-disable dialog
* from carrier config manager.
*
* @return boolean value of the config
*/
private boolean isSkipCFFailToDisableDialog() {
PersistableBundle carrierConfig =
PhoneGlobals.getInstance().getCarrierConfigForSubId(mPhone.getSubId());
if (carrierConfig != null) {
return carrierConfig.getBoolean(
CarrierConfigManager.KEY_SKIP_CF_FAIL_TO_DISABLE_DIALOG_BOOL);
} else {
// by default we should not skip
return false;
}
}
}