blob: 2b77b461983b3e6bac7fa6a19d7a4b579c7e23c9 [file] [log] [blame]
/*
* Copyright (C) 2011 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.dialer.dialpad;
import android.app.Activity;
import android.app.AlertDialog;
import android.app.Dialog;
import android.app.DialogFragment;
import android.app.Fragment;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.res.Resources;
import android.database.Cursor;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.media.AudioManager;
import android.media.ToneGenerator;
import android.net.Uri;
import android.os.Bundle;
import android.os.RemoteException;
import android.os.ServiceManager;
import android.os.SystemProperties;
import android.provider.Contacts.Intents.Insert;
import android.provider.Contacts.People;
import android.provider.Contacts.Phones;
import android.provider.Contacts.PhonesColumns;
import android.provider.Settings;
import android.telephony.PhoneNumberUtils;
import android.telephony.PhoneStateListener;
import android.telephony.TelephonyManager;
import android.text.Editable;
import android.text.SpannableString;
import android.text.TextUtils;
import android.text.TextWatcher;
import android.text.method.DialerKeyListener;
import android.text.style.RelativeSizeSpan;
import android.util.DisplayMetrics;
import android.util.Log;
import android.view.KeyEvent;
import android.view.LayoutInflater;
import android.view.Menu;
import android.view.MenuInflater;
import android.view.MenuItem;
import android.view.View;
import android.view.ViewConfiguration;
import android.view.ViewGroup;
import android.widget.AdapterView;
import android.widget.BaseAdapter;
import android.widget.EditText;
import android.widget.ImageView;
import android.widget.ListView;
import android.widget.PopupMenu;
import android.widget.TextView;
import com.android.contacts.common.CallUtil;
import com.android.contacts.common.GeoUtil;
import com.android.contacts.common.util.PhoneNumberFormatter;
import com.android.contacts.common.util.StopWatch;
import com.android.dialer.DialtactsActivity;
import com.android.dialer.R;
import com.android.dialer.SpecialCharSequenceMgr;
import com.android.dialer.util.OrientationUtil;
import com.android.internal.telephony.ITelephony;
import com.android.phone.common.CallLogAsync;
import com.android.phone.common.HapticFeedback;
/**
* Fragment that displays a twelve-key phone dialpad.
*/
public class DialpadFragment extends Fragment
implements View.OnClickListener,
View.OnLongClickListener, View.OnKeyListener,
AdapterView.OnItemClickListener, TextWatcher,
PopupMenu.OnMenuItemClickListener,
DialpadImageButton.OnPressedListener {
private static final String TAG = DialpadFragment.class.getSimpleName();
private static final boolean DEBUG = DialtactsActivity.DEBUG;
private static final String EMPTY_NUMBER = "";
/** The length of DTMF tones in milliseconds */
private static final int TONE_LENGTH_MS = 150;
private static final int TONE_LENGTH_INFINITE = -1;
/** The DTMF tone volume relative to other sounds in the stream */
private static final int TONE_RELATIVE_VOLUME = 80;
/** Stream type used to play the DTMF tones off call, and mapped to the volume control keys */
private static final int DIAL_TONE_STREAM_TYPE = AudioManager.STREAM_DTMF;
/**
* View (usually FrameLayout) containing mDigits field. This can be null, in which mDigits
* isn't enclosed by the container.
*/
private View mDigitsContainer;
private EditText mDigits;
/** Remembers if we need to clear digits field when the screen is completely gone. */
private boolean mClearDigitsOnStop;
private View mDelete;
private ToneGenerator mToneGenerator;
private final Object mToneGeneratorLock = new Object();
private View mDialpad;
/**
* Remembers the number of dialpad buttons which are pressed at this moment.
* If it becomes 0, meaning no buttons are pressed, we'll call
* {@link ToneGenerator#stopTone()}; the method shouldn't be called unless the last key is
* released.
*/
private int mDialpadPressCount;
private View mDialButtonContainer;
private View mDialButton;
private ListView mDialpadChooser;
private DialpadChooserAdapter mDialpadChooserAdapter;
/**
* Regular expression prohibiting manual phone call. Can be empty, which means "no rule".
*/
private String mProhibitedPhoneNumberRegexp;
// Last number dialed, retrieved asynchronously from the call DB
// in onCreate. This number is displayed when the user hits the
// send key and cleared in onPause.
private final CallLogAsync mCallLog = new CallLogAsync();
private String mLastNumberDialed = EMPTY_NUMBER;
// determines if we want to playback local DTMF tones.
private boolean mDTMFToneEnabled;
// Vibration (haptic feedback) for dialer key presses.
private final HapticFeedback mHaptic = new HapticFeedback();
/** Identifier for the "Add Call" intent extra. */
private static final String ADD_CALL_MODE_KEY = "add_call_mode";
/**
* Identifier for intent extra for sending an empty Flash message for
* CDMA networks. This message is used by the network to simulate a
* press/depress of the "hookswitch" of a landline phone. Aka "empty flash".
*
* TODO: Using an intent extra to tell the phone to send this flash is a
* temporary measure. To be replaced with an ITelephony call in the future.
* TODO: Keep in sync with the string defined in OutgoingCallBroadcaster.java
* in Phone app until this is replaced with the ITelephony API.
*/
private static final String EXTRA_SEND_EMPTY_FLASH
= "com.android.phone.extra.SEND_EMPTY_FLASH";
private String mCurrentCountryIso;
private final PhoneStateListener mPhoneStateListener = new PhoneStateListener() {
/**
* Listen for phone state changes so that we can take down the
* "dialpad chooser" if the phone becomes idle while the
* chooser UI is visible.
*/
@Override
public void onCallStateChanged(int state, String incomingNumber) {
// Log.i(TAG, "PhoneStateListener.onCallStateChanged: "
// + state + ", '" + incomingNumber + "'");
if ((state == TelephonyManager.CALL_STATE_IDLE) && dialpadChooserVisible()) {
// Log.i(TAG, "Call ended with dialpad chooser visible! Taking it down...");
// Note there's a race condition in the UI here: the
// dialpad chooser could conceivably disappear (on its
// own) at the exact moment the user was trying to select
// one of the choices, which would be confusing. (But at
// least that's better than leaving the dialpad chooser
// onscreen, but useless...)
showDialpadChooser(false);
}
}
};
private boolean mWasEmptyBeforeTextChange;
/**
* This field is set to true while processing an incoming DIAL intent, in order to make sure
* that SpecialCharSequenceMgr actions can be triggered by user input but *not* by a
* tel: URI passed by some other app. It will be set to false when all digits are cleared.
*/
private boolean mDigitsFilledByIntent;
private static final String PREF_DIGITS_FILLED_BY_INTENT = "pref_digits_filled_by_intent";
/**
* Return an Intent for launching voicemail screen.
*/
private static Intent getVoicemailIntent() {
final Intent intent = new Intent(Intent.ACTION_CALL_PRIVILEGED,
Uri.fromParts("voicemail", "", null));
intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
return intent;
}
@Override
public void beforeTextChanged(CharSequence s, int start, int count, int after) {
mWasEmptyBeforeTextChange = TextUtils.isEmpty(s);
}
@Override
public void onTextChanged(CharSequence input, int start, int before, int changeCount) {
if (mWasEmptyBeforeTextChange != TextUtils.isEmpty(input)) {
final Activity activity = getActivity();
if (activity != null) {
activity.invalidateOptionsMenu();
}
}
// DTMF Tones do not need to be played here any longer -
// the DTMF dialer handles that functionality now.
}
@Override
public void afterTextChanged(Editable input) {
// When DTMF dialpad buttons are being pressed, we delay SpecialCharSequencMgr sequence,
// since some of SpecialCharSequenceMgr's behavior is too abrupt for the "touch-down"
// behavior.
if (!mDigitsFilledByIntent &&
SpecialCharSequenceMgr.handleChars(getActivity(), input.toString(), mDigits)) {
// A special sequence was entered, clear the digits
mDigits.getText().clear();
}
if (isDigitsEmpty()) {
mDigitsFilledByIntent = false;
mDigits.setCursorVisible(false);
}
updateDialAndDeleteButtonEnabledState();
}
@Override
public void onCreate(Bundle state) {
super.onCreate(state);
mCurrentCountryIso = GeoUtil.getCurrentCountryIso(getActivity());
try {
mHaptic.init(getActivity(),
getResources().getBoolean(R.bool.config_enable_dialer_key_vibration));
} catch (Resources.NotFoundException nfe) {
Log.e(TAG, "Vibrate control bool missing.", nfe);
}
setHasOptionsMenu(true);
mProhibitedPhoneNumberRegexp = getResources().getString(
R.string.config_prohibited_phone_number_regexp);
if (state != null) {
mDigitsFilledByIntent = state.getBoolean(PREF_DIGITS_FILLED_BY_INTENT);
}
}
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedState) {
View fragmentView = inflater.inflate(R.layout.dialpad_fragment, container, false);
// Load up the resources for the text field.
Resources r = getResources();
mDigitsContainer = fragmentView.findViewById(R.id.digits_container);
mDigits = (EditText) fragmentView.findViewById(R.id.digits);
mDigits.setKeyListener(DialerKeyListener.getInstance());
mDigits.setOnClickListener(this);
mDigits.setOnKeyListener(this);
mDigits.setOnLongClickListener(this);
mDigits.addTextChangedListener(this);
PhoneNumberFormatter.setPhoneNumberFormattingTextWatcher(getActivity(), mDigits);
// Check for the presence of the keypad
View oneButton = fragmentView.findViewById(R.id.one);
if (oneButton != null) {
setupKeypad(fragmentView);
}
DisplayMetrics dm = getResources().getDisplayMetrics();
int minCellSize = (int) (56 * dm.density); // 56dip == minimum size of menu buttons
int cellCount = dm.widthPixels / minCellSize;
int fakeMenuItemWidth = dm.widthPixels / cellCount;
mDialButtonContainer = fragmentView.findViewById(R.id.dialButtonContainer);
// If in portrait, add padding to the dial button since we need space for the
// search and menu/overflow buttons.
if (mDialButtonContainer != null && !OrientationUtil.isLandscape(this.getActivity())) {
mDialButtonContainer.setPadding(
fakeMenuItemWidth, mDialButtonContainer.getPaddingTop(),
fakeMenuItemWidth, mDialButtonContainer.getPaddingBottom());
}
mDialButton = fragmentView.findViewById(R.id.dialButton);
if (r.getBoolean(R.bool.config_show_onscreen_dial_button)) {
mDialButton.setOnClickListener(this);
mDialButton.setOnLongClickListener(this);
} else {
mDialButton.setVisibility(View.GONE); // It's VISIBLE by default
mDialButton = null;
}
mDelete = fragmentView.findViewById(R.id.deleteButton);
if (mDelete != null) {
mDelete.setOnClickListener(this);
mDelete.setOnLongClickListener(this);
}
mDialpad = fragmentView.findViewById(R.id.dialpad); // This is null in landscape mode.
// In landscape we put the keyboard in phone mode.
if (null == mDialpad) {
mDigits.setInputType(android.text.InputType.TYPE_CLASS_PHONE);
} else {
mDigits.setCursorVisible(false);
}
// Set up the "dialpad chooser" UI; see showDialpadChooser().
mDialpadChooser = (ListView) fragmentView.findViewById(R.id.dialpadChooser);
mDialpadChooser.setOnItemClickListener(this);
configureScreenFromIntent(getActivity().getIntent());
return fragmentView;
}
private boolean isLayoutReady() {
return mDigits != null;
}
public EditText getDigitsWidget() {
return mDigits;
}
/**
* @return true when {@link #mDigits} is actually filled by the Intent.
*/
private boolean fillDigitsIfNecessary(Intent intent) {
final String action = intent.getAction();
if (Intent.ACTION_DIAL.equals(action) || Intent.ACTION_VIEW.equals(action)) {
Uri uri = intent.getData();
if (uri != null) {
if (CallUtil.SCHEME_TEL.equals(uri.getScheme())) {
// Put the requested number into the input area
String data = uri.getSchemeSpecificPart();
// Remember it is filled via Intent.
mDigitsFilledByIntent = true;
setFormattedDigits(data, null);
return true;
} else {
String type = intent.getType();
if (People.CONTENT_ITEM_TYPE.equals(type)
|| Phones.CONTENT_ITEM_TYPE.equals(type)) {
// Query the phone number
Cursor c = getActivity().getContentResolver().query(intent.getData(),
new String[] {PhonesColumns.NUMBER, PhonesColumns.NUMBER_KEY},
null, null, null);
if (c != null) {
try {
if (c.moveToFirst()) {
// Remember it is filled via Intent.
mDigitsFilledByIntent = true;
// Put the number into the input area
setFormattedDigits(c.getString(0), c.getString(1));
return true;
}
} finally {
c.close();
}
}
}
}
}
}
return false;
}
/**
* @see #showDialpadChooser(boolean)
*/
private static boolean needToShowDialpadChooser(Intent intent, boolean isAddCallMode) {
final String action = intent.getAction();
boolean needToShowDialpadChooser = false;
if (Intent.ACTION_DIAL.equals(action) || Intent.ACTION_VIEW.equals(action)) {
Uri uri = intent.getData();
if (uri == null) {
// ACTION_DIAL or ACTION_VIEW with no data.
// This behaves basically like ACTION_MAIN: If there's
// already an active call, bring up an intermediate UI to
// make the user confirm what they really want to do.
// Be sure *not* to show the dialpad chooser if this is an
// explicit "Add call" action, though.
if (!isAddCallMode && phoneIsInUse()) {
needToShowDialpadChooser = true;
}
}
} else if (Intent.ACTION_MAIN.equals(action)) {
// The MAIN action means we're bringing up a blank dialer
// (e.g. by selecting the Home shortcut, or tabbing over from
// Contacts or Call log.)
//
// At this point, IF there's already an active call, there's a
// good chance that the user got here accidentally (but really
// wanted the in-call dialpad instead). So we bring up an
// intermediate UI to make the user confirm what they really
// want to do.
if (phoneIsInUse()) {
// Log.i(TAG, "resolveIntent(): phone is in use; showing dialpad chooser!");
needToShowDialpadChooser = true;
}
}
return needToShowDialpadChooser;
}
private static boolean isAddCallMode(Intent intent) {
final String action = intent.getAction();
if (Intent.ACTION_DIAL.equals(action) || Intent.ACTION_VIEW.equals(action)) {
// see if we are "adding a call" from the InCallScreen; false by default.
return intent.getBooleanExtra(ADD_CALL_MODE_KEY, false);
} else {
return false;
}
}
/**
* Checks the given Intent and changes dialpad's UI state. For example, if the Intent requires
* the screen to enter "Add Call" mode, this method will show correct UI for the mode.
*/
public void configureScreenFromIntent(Intent intent) {
if (!isLayoutReady()) {
// This happens typically when parent's Activity#onNewIntent() is called while
// Fragment#onCreateView() isn't called yet, and thus we cannot configure Views at
// this point. onViewCreate() should call this method after preparing layouts, so
// just ignore this call now.
Log.i(TAG,
"Screen configuration is requested before onCreateView() is called. Ignored");
return;
}
boolean needToShowDialpadChooser = false;
final boolean isAddCallMode = isAddCallMode(intent);
if (!isAddCallMode) {
final boolean digitsFilled = fillDigitsIfNecessary(intent);
if (!digitsFilled) {
needToShowDialpadChooser = needToShowDialpadChooser(intent, isAddCallMode);
}
}
showDialpadChooser(needToShowDialpadChooser);
}
/**
* Sets formatted digits to digits field.
*/
private void setFormattedDigits(String data, String normalizedNumber) {
// strip the non-dialable numbers out of the data string.
String dialString = PhoneNumberUtils.extractNetworkPortion(data);
dialString =
PhoneNumberUtils.formatNumber(dialString, normalizedNumber, mCurrentCountryIso);
if (!TextUtils.isEmpty(dialString)) {
Editable digits = mDigits.getText();
digits.replace(0, digits.length(), dialString);
// for some reason this isn't getting called in the digits.replace call above..
// but in any case, this will make sure the background drawable looks right
afterTextChanged(digits);
}
}
private void setupKeypad(View fragmentView) {
int[] buttonIds = new int[] { R.id.one, R.id.two, R.id.three, R.id.four, R.id.five,
R.id.six, R.id.seven, R.id.eight, R.id.nine, R.id.zero, R.id.star, R.id.pound};
for (int id : buttonIds) {
((DialpadImageButton) fragmentView.findViewById(id)).setOnPressedListener(this);
}
// Long-pressing one button will initiate Voicemail.
fragmentView.findViewById(R.id.one).setOnLongClickListener(this);
// Long-pressing zero button will enter '+' instead.
fragmentView.findViewById(R.id.zero).setOnLongClickListener(this);
}
@Override
public void onResume() {
super.onResume();
final StopWatch stopWatch = StopWatch.start("Dialpad.onResume");
// Query the last dialed number. Do it first because hitting
// the DB is 'slow'. This call is asynchronous.
queryLastOutgoingCall();
stopWatch.lap("qloc");
// retrieve the DTMF tone play back setting.
mDTMFToneEnabled = Settings.System.getInt(getActivity().getContentResolver(),
Settings.System.DTMF_TONE_WHEN_DIALING, 1) == 1;
stopWatch.lap("dtwd");
// Retrieve the haptic feedback setting.
mHaptic.checkSystemSetting();
stopWatch.lap("hptc");
// if the mToneGenerator creation fails, just continue without it. It is
// a local audio signal, and is not as important as the dtmf tone itself.
synchronized (mToneGeneratorLock) {
if (mToneGenerator == null) {
try {
mToneGenerator = new ToneGenerator(DIAL_TONE_STREAM_TYPE, TONE_RELATIVE_VOLUME);
} catch (RuntimeException e) {
Log.w(TAG, "Exception caught while creating local tone generator: " + e);
mToneGenerator = null;
}
}
}
stopWatch.lap("tg");
// Prevent unnecessary confusion. Reset the press count anyway.
mDialpadPressCount = 0;
Activity parent = getActivity();
if (parent instanceof DialtactsActivity) {
// See if we were invoked with a DIAL intent. If we were, fill in the appropriate
// digits in the dialer field.
fillDigitsIfNecessary(parent.getIntent());
}
stopWatch.lap("fdin");
// While we're in the foreground, listen for phone state changes,
// purely so that we can take down the "dialpad chooser" if the
// phone becomes idle while the chooser UI is visible.
TelephonyManager telephonyManager =
(TelephonyManager) getActivity().getSystemService(Context.TELEPHONY_SERVICE);
telephonyManager.listen(mPhoneStateListener, PhoneStateListener.LISTEN_CALL_STATE);
stopWatch.lap("tm");
// Potentially show hint text in the mDigits field when the user
// hasn't typed any digits yet. (If there's already an active call,
// this hint text will remind the user that he's about to add a new
// call.)
//
// TODO: consider adding better UI for the case where *both* lines
// are currently in use. (Right now we let the user try to add
// another call, but that call is guaranteed to fail. Perhaps the
// entire dialer UI should be disabled instead.)
if (phoneIsInUse()) {
final SpannableString hint = new SpannableString(
getActivity().getString(R.string.dialerDialpadHintText));
hint.setSpan(new RelativeSizeSpan(0.8f), 0, hint.length(), 0);
mDigits.setHint(hint);
} else {
// Common case; no hint necessary.
mDigits.setHint(null);
// Also, a sanity-check: the "dialpad chooser" UI should NEVER
// be visible if the phone is idle!
showDialpadChooser(false);
}
stopWatch.lap("hnt");
updateDialAndDeleteButtonEnabledState();
stopWatch.lap("bes");
stopWatch.stopAndLog(TAG, 50);
}
@Override
public void onPause() {
super.onPause();
// Stop listening for phone state changes.
TelephonyManager telephonyManager =
(TelephonyManager) getActivity().getSystemService(Context.TELEPHONY_SERVICE);
telephonyManager.listen(mPhoneStateListener, PhoneStateListener.LISTEN_NONE);
// Make sure we don't leave this activity with a tone still playing.
stopTone();
// Just in case reset the counter too.
mDialpadPressCount = 0;
synchronized (mToneGeneratorLock) {
if (mToneGenerator != null) {
mToneGenerator.release();
mToneGenerator = null;
}
}
// TODO: I wonder if we should not check if the AsyncTask that
// lookup the last dialed number has completed.
mLastNumberDialed = EMPTY_NUMBER; // Since we are going to query again, free stale number.
SpecialCharSequenceMgr.cleanup();
}
@Override
public void onStop() {
super.onStop();
if (mClearDigitsOnStop) {
mClearDigitsOnStop = false;
mDigits.getText().clear();
}
}
@Override
public void onSaveInstanceState(Bundle outState) {
super.onSaveInstanceState(outState);
outState.putBoolean(PREF_DIGITS_FILLED_BY_INTENT, mDigitsFilledByIntent);
}
@Override
public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
super.onCreateOptionsMenu(menu, inflater);
// Landscape dialer uses the real actionbar menu, whereas portrait uses a fake one
// that is created using constructPopupMenu()
if (OrientationUtil.isLandscape(this.getActivity()) ||
ViewConfiguration.get(getActivity()).hasPermanentMenuKey() &&
isLayoutReady() && mDialpadChooser != null) {
inflater.inflate(R.menu.dialpad_options, menu);
}
}
@Override
public void onPrepareOptionsMenu(Menu menu) {
// Hardware menu key should be available and Views should already be ready.
if (OrientationUtil.isLandscape(this.getActivity()) ||
ViewConfiguration.get(getActivity()).hasPermanentMenuKey() &&
isLayoutReady() && mDialpadChooser != null) {
setupMenuItems(menu);
}
}
private void setupMenuItems(Menu menu) {
final MenuItem callSettingsMenuItem = menu.findItem(R.id.menu_call_settings_dialpad);
final MenuItem addToContactMenuItem = menu.findItem(R.id.menu_add_contacts);
final MenuItem twoSecPauseMenuItem = menu.findItem(R.id.menu_2s_pause);
final MenuItem waitMenuItem = menu.findItem(R.id.menu_add_wait);
// Check if all the menu items are inflated correctly. As a shortcut, we assume all menu
// items are ready if the first item is non-null.
if (callSettingsMenuItem == null) {
return;
}
final Activity activity = getActivity();
if (activity != null && ViewConfiguration.get(activity).hasPermanentMenuKey()) {
// Call settings should be available via its parent Activity.
callSettingsMenuItem.setVisible(false);
} else {
callSettingsMenuItem.setVisible(true);
callSettingsMenuItem.setIntent(DialtactsActivity.getCallSettingsIntent());
}
// We show "add to contacts", "2sec pause", and "add wait" menus only when the user is
// seeing usual dialpads and has typed at least one digit.
// We never show a menu if the "choose dialpad" UI is up.
if (dialpadChooserVisible() || isDigitsEmpty()) {
addToContactMenuItem.setVisible(false);
twoSecPauseMenuItem.setVisible(false);
waitMenuItem.setVisible(false);
} else {
final CharSequence digits = mDigits.getText();
// Put the current digits string into an intent
addToContactMenuItem.setIntent(getAddToContactIntent(digits));
addToContactMenuItem.setVisible(true);
// Check out whether to show Pause & Wait option menu items
int selectionStart;
int selectionEnd;
String strDigits = digits.toString();
selectionStart = mDigits.getSelectionStart();
selectionEnd = mDigits.getSelectionEnd();
if (selectionStart != -1) {
if (selectionStart > selectionEnd) {
// swap it as we want start to be less then end
int tmp = selectionStart;
selectionStart = selectionEnd;
selectionEnd = tmp;
}
if (selectionStart != 0) {
// Pause can be visible if cursor is not in the begining
twoSecPauseMenuItem.setVisible(true);
// For Wait to be visible set of condition to meet
waitMenuItem.setVisible(showWait(selectionStart, selectionEnd, strDigits));
} else {
// cursor in the beginning both pause and wait to be invisible
twoSecPauseMenuItem.setVisible(false);
waitMenuItem.setVisible(false);
}
} else {
twoSecPauseMenuItem.setVisible(true);
// cursor is not selected so assume new digit is added to the end
int strLength = strDigits.length();
waitMenuItem.setVisible(showWait(strLength, strLength, strDigits));
}
}
}
private static Intent getAddToContactIntent(CharSequence digits) {
final Intent intent = new Intent(Intent.ACTION_INSERT_OR_EDIT);
intent.putExtra(Insert.PHONE, digits);
intent.setType(People.CONTENT_ITEM_TYPE);
return intent;
}
private void keyPressed(int keyCode) {
switch (keyCode) {
case KeyEvent.KEYCODE_1:
playTone(ToneGenerator.TONE_DTMF_1, TONE_LENGTH_INFINITE);
break;
case KeyEvent.KEYCODE_2:
playTone(ToneGenerator.TONE_DTMF_2, TONE_LENGTH_INFINITE);
break;
case KeyEvent.KEYCODE_3:
playTone(ToneGenerator.TONE_DTMF_3, TONE_LENGTH_INFINITE);
break;
case KeyEvent.KEYCODE_4:
playTone(ToneGenerator.TONE_DTMF_4, TONE_LENGTH_INFINITE);
break;
case KeyEvent.KEYCODE_5:
playTone(ToneGenerator.TONE_DTMF_5, TONE_LENGTH_INFINITE);
break;
case KeyEvent.KEYCODE_6:
playTone(ToneGenerator.TONE_DTMF_6, TONE_LENGTH_INFINITE);
break;
case KeyEvent.KEYCODE_7:
playTone(ToneGenerator.TONE_DTMF_7, TONE_LENGTH_INFINITE);
break;
case KeyEvent.KEYCODE_8:
playTone(ToneGenerator.TONE_DTMF_8, TONE_LENGTH_INFINITE);
break;
case KeyEvent.KEYCODE_9:
playTone(ToneGenerator.TONE_DTMF_9, TONE_LENGTH_INFINITE);
break;
case KeyEvent.KEYCODE_0:
playTone(ToneGenerator.TONE_DTMF_0, TONE_LENGTH_INFINITE);
break;
case KeyEvent.KEYCODE_POUND:
playTone(ToneGenerator.TONE_DTMF_P, TONE_LENGTH_INFINITE);
break;
case KeyEvent.KEYCODE_STAR:
playTone(ToneGenerator.TONE_DTMF_S, TONE_LENGTH_INFINITE);
break;
default:
break;
}
mHaptic.vibrate();
KeyEvent event = new KeyEvent(KeyEvent.ACTION_DOWN, keyCode);
mDigits.onKeyDown(keyCode, event);
// If the cursor is at the end of the text we hide it.
final int length = mDigits.length();
if (length == mDigits.getSelectionStart() && length == mDigits.getSelectionEnd()) {
mDigits.setCursorVisible(false);
}
}
@Override
public boolean onKey(View view, int keyCode, KeyEvent event) {
switch (view.getId()) {
case R.id.digits:
if (keyCode == KeyEvent.KEYCODE_ENTER) {
dialButtonPressed();
return true;
}
break;
}
return false;
}
/**
* When a key is pressed, we start playing DTMF tone, do vibration, and enter the digit
* immediately. When a key is released, we stop the tone. Note that the "key press" event will
* be delivered by the system with certain amount of delay, it won't be synced with user's
* actual "touch-down" behavior.
*/
@Override
public void onPressed(View view, boolean pressed) {
if (DEBUG) Log.d(TAG, "onPressed(). view: " + view + ", pressed: " + pressed);
if (pressed) {
switch (view.getId()) {
case R.id.one: {
keyPressed(KeyEvent.KEYCODE_1);
break;
}
case R.id.two: {
keyPressed(KeyEvent.KEYCODE_2);
break;
}
case R.id.three: {
keyPressed(KeyEvent.KEYCODE_3);
break;
}
case R.id.four: {
keyPressed(KeyEvent.KEYCODE_4);
break;
}
case R.id.five: {
keyPressed(KeyEvent.KEYCODE_5);
break;
}
case R.id.six: {
keyPressed(KeyEvent.KEYCODE_6);
break;
}
case R.id.seven: {
keyPressed(KeyEvent.KEYCODE_7);
break;
}
case R.id.eight: {
keyPressed(KeyEvent.KEYCODE_8);
break;
}
case R.id.nine: {
keyPressed(KeyEvent.KEYCODE_9);
break;
}
case R.id.zero: {
keyPressed(KeyEvent.KEYCODE_0);
break;
}
case R.id.pound: {
keyPressed(KeyEvent.KEYCODE_POUND);
break;
}
case R.id.star: {
keyPressed(KeyEvent.KEYCODE_STAR);
break;
}
default: {
Log.wtf(TAG, "Unexpected onTouch(ACTION_DOWN) event from: " + view);
break;
}
}
mDialpadPressCount++;
} else {
view.jumpDrawablesToCurrentState();
mDialpadPressCount--;
if (mDialpadPressCount < 0) {
// e.g.
// - when the user action is detected as horizontal swipe, at which only
// "up" event is thrown.
// - when the user long-press '0' button, at which dialpad will decrease this count
// while it still gets press-up event here.
if (DEBUG) Log.d(TAG, "mKeyPressCount become negative.");
stopTone();
mDialpadPressCount = 0;
} else if (mDialpadPressCount == 0) {
stopTone();
}
}
}
@Override
public void onClick(View view) {
switch (view.getId()) {
case R.id.deleteButton: {
keyPressed(KeyEvent.KEYCODE_DEL);
return;
}
case R.id.dialButton: {
mHaptic.vibrate(); // Vibrate here too, just like we do for the regular keys
dialButtonPressed();
return;
}
case R.id.digits: {
if (!isDigitsEmpty()) {
mDigits.setCursorVisible(true);
}
return;
}
default: {
Log.wtf(TAG, "Unexpected onClick() event from: " + view);
return;
}
}
}
public PopupMenu constructPopupMenu(View anchorView) {
final Context context = getActivity();
if (context == null) {
return null;
}
final PopupMenu popupMenu = new PopupMenu(context, anchorView);
final Menu menu = popupMenu.getMenu();
popupMenu.inflate(R.menu.dialpad_options);
popupMenu.setOnMenuItemClickListener(this);
setupMenuItems(menu);
return popupMenu;
}
@Override
public boolean onLongClick(View view) {
final Editable digits = mDigits.getText();
final int id = view.getId();
switch (id) {
case R.id.deleteButton: {
digits.clear();
// TODO: The framework forgets to clear the pressed
// status of disabled button. Until this is fixed,
// clear manually the pressed status. b/2133127
mDelete.setPressed(false);
return true;
}
case R.id.one: {
// '1' may be already entered since we rely on onTouch() event for numeric buttons.
// Just for safety we also check if the digits field is empty or not.
if (isDigitsEmpty() || TextUtils.equals(mDigits.getText(), "1")) {
// We'll try to initiate voicemail and thus we want to remove irrelevant string.
removePreviousDigitIfPossible();
if (isVoicemailAvailable()) {
callVoicemail();
} else if (getActivity() != null) {
// Voicemail is unavailable maybe because Airplane mode is turned on.
// Check the current status and show the most appropriate error message.
final boolean isAirplaneModeOn =
Settings.System.getInt(getActivity().getContentResolver(),
Settings.System.AIRPLANE_MODE_ON, 0) != 0;
if (isAirplaneModeOn) {
DialogFragment dialogFragment = ErrorDialogFragment.newInstance(
R.string.dialog_voicemail_airplane_mode_message);
dialogFragment.show(getFragmentManager(),
"voicemail_request_during_airplane_mode");
} else {
DialogFragment dialogFragment = ErrorDialogFragment.newInstance(
R.string.dialog_voicemail_not_ready_message);
dialogFragment.show(getFragmentManager(), "voicemail_not_ready");
}
}
return true;
}
return false;
}
case R.id.zero: {
// Remove tentative input ('0') done by onTouch().
removePreviousDigitIfPossible();
keyPressed(KeyEvent.KEYCODE_PLUS);
// Stop tone immediately and decrease the press count, so that possible subsequent
// dial button presses won't honor the 0 click any more.
// Note: this *will* make mDialpadPressCount negative when the 0 key is released,
// which should be handled appropriately.
stopTone();
if (mDialpadPressCount > 0) mDialpadPressCount--;
return true;
}
case R.id.digits: {
// Right now EditText does not show the "paste" option when cursor is not visible.
// To show that, make the cursor visible, and return false, letting the EditText
// show the option by itself.
mDigits.setCursorVisible(true);
return false;
}
case R.id.dialButton: {
if (isDigitsEmpty()) {
handleDialButtonClickWithEmptyDigits();
// This event should be consumed so that onClick() won't do the exactly same
// thing.
return true;
} else {
return false;
}
}
}
return false;
}
/**
* Remove the digit just before the current position. This can be used if we want to replace
* the previous digit or cancel previously entered character.
*/
private void removePreviousDigitIfPossible() {
final Editable editable = mDigits.getText();
final int currentPosition = mDigits.getSelectionStart();
if (currentPosition > 0) {
mDigits.setSelection(currentPosition);
mDigits.getText().delete(currentPosition - 1, currentPosition);
}
}
public void callVoicemail() {
startActivity(getVoicemailIntent());
mClearDigitsOnStop = true;
getActivity().finish();
}
public static class ErrorDialogFragment extends DialogFragment {
private int mTitleResId;
private int mMessageResId;
private static final String ARG_TITLE_RES_ID = "argTitleResId";
private static final String ARG_MESSAGE_RES_ID = "argMessageResId";
public static ErrorDialogFragment newInstance(int messageResId) {
return newInstance(0, messageResId);
}
public static ErrorDialogFragment newInstance(int titleResId, int messageResId) {
final ErrorDialogFragment fragment = new ErrorDialogFragment();
final Bundle args = new Bundle();
args.putInt(ARG_TITLE_RES_ID, titleResId);
args.putInt(ARG_MESSAGE_RES_ID, messageResId);
fragment.setArguments(args);
return fragment;
}
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
mTitleResId = getArguments().getInt(ARG_TITLE_RES_ID);
mMessageResId = getArguments().getInt(ARG_MESSAGE_RES_ID);
}
@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
if (mTitleResId != 0) {
builder.setTitle(mTitleResId);
}
if (mMessageResId != 0) {
builder.setMessage(mMessageResId);
}
builder.setPositiveButton(android.R.string.ok,
new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
dismiss();
}
});
return builder.create();
}
}
/**
* In most cases, when the dial button is pressed, there is a
* number in digits area. Pack it in the intent, start the
* outgoing call broadcast as a separate task and finish this
* activity.
*
* When there is no digit and the phone is CDMA and off hook,
* we're sending a blank flash for CDMA. CDMA networks use Flash
* messages when special processing needs to be done, mainly for
* 3-way or call waiting scenarios. Presumably, here we're in a
* special 3-way scenario where the network needs a blank flash
* before being able to add the new participant. (This is not the
* case with all 3-way calls, just certain CDMA infrastructures.)
*
* Otherwise, there is no digit, display the last dialed
* number. Don't finish since the user may want to edit it. The
* user needs to press the dial button again, to dial it (general
* case described above).
*/
public void dialButtonPressed() {
if (isDigitsEmpty()) { // No number entered.
handleDialButtonClickWithEmptyDigits();
} else {
final String number = mDigits.getText().toString();
// "persist.radio.otaspdial" is a temporary hack needed for one carrier's automated
// test equipment.
// TODO: clean it up.
if (number != null
&& !TextUtils.isEmpty(mProhibitedPhoneNumberRegexp)
&& number.matches(mProhibitedPhoneNumberRegexp)
&& (SystemProperties.getInt("persist.radio.otaspdial", 0) != 1)) {
Log.i(TAG, "The phone number is prohibited explicitly by a rule.");
if (getActivity() != null) {
DialogFragment dialogFragment = ErrorDialogFragment.newInstance(
R.string.dialog_phone_call_prohibited_message);
dialogFragment.show(getFragmentManager(), "phone_prohibited_dialog");
}
// Clear the digits just in case.
mDigits.getText().clear();
} else {
final Intent intent = CallUtil.getCallIntent(number,
(getActivity() instanceof DialtactsActivity ?
((DialtactsActivity) getActivity()).getCallOrigin() : null));
startActivity(intent);
mClearDigitsOnStop = true;
getActivity().finish();
}
}
}
private void handleDialButtonClickWithEmptyDigits() {
if (phoneIsCdma() && phoneIsOffhook()) {
// This is really CDMA specific. On GSM is it possible
// to be off hook and wanted to add a 3rd party using
// the redial feature.
startActivity(newFlashIntent());
} else {
if (!TextUtils.isEmpty(mLastNumberDialed)) {
// Recall the last number dialed.
mDigits.setText(mLastNumberDialed);
// ...and move the cursor to the end of the digits string,
// so you'll be able to delete digits using the Delete
// button (just as if you had typed the number manually.)
//
// Note we use mDigits.getText().length() here, not
// mLastNumberDialed.length(), since the EditText widget now
// contains a *formatted* version of mLastNumberDialed (due to
// mTextWatcher) and its length may have changed.
mDigits.setSelection(mDigits.getText().length());
} else {
// There's no "last number dialed" or the
// background query is still running. There's
// nothing useful for the Dial button to do in
// this case. Note: with a soft dial button, this
// can never happens since the dial button is
// disabled under these conditons.
playTone(ToneGenerator.TONE_PROP_NACK);
}
}
}
/**
* Plays the specified tone for TONE_LENGTH_MS milliseconds.
*/
private void playTone(int tone) {
playTone(tone, TONE_LENGTH_MS);
}
/**
* Play the specified tone for the specified milliseconds
*
* The tone is played locally, using the audio stream for phone calls.
* Tones are played only if the "Audible touch tones" user preference
* is checked, and are NOT played if the device is in silent mode.
*
* The tone length can be -1, meaning "keep playing the tone." If the caller does so, it should
* call stopTone() afterward.
*
* @param tone a tone code from {@link ToneGenerator}
* @param durationMs tone length.
*/
private void playTone(int tone, int durationMs) {
// if local tone playback is disabled, just return.
if (!mDTMFToneEnabled) {
return;
}
// Also do nothing if the phone is in silent mode.
// We need to re-check the ringer mode for *every* playTone()
// call, rather than keeping a local flag that's updated in
// onResume(), since it's possible to toggle silent mode without
// leaving the current activity (via the ENDCALL-longpress menu.)
AudioManager audioManager =
(AudioManager) getActivity().getSystemService(Context.AUDIO_SERVICE);
int ringerMode = audioManager.getRingerMode();
if ((ringerMode == AudioManager.RINGER_MODE_SILENT)
|| (ringerMode == AudioManager.RINGER_MODE_VIBRATE)) {
return;
}
synchronized (mToneGeneratorLock) {
if (mToneGenerator == null) {
Log.w(TAG, "playTone: mToneGenerator == null, tone: " + tone);
return;
}
// Start the new tone (will stop any playing tone)
mToneGenerator.startTone(tone, durationMs);
}
}
/**
* Stop the tone if it is played.
*/
private void stopTone() {
// if local tone playback is disabled, just return.
if (!mDTMFToneEnabled) {
return;
}
synchronized (mToneGeneratorLock) {
if (mToneGenerator == null) {
Log.w(TAG, "stopTone: mToneGenerator == null");
return;
}
mToneGenerator.stopTone();
}
}
/**
* Brings up the "dialpad chooser" UI in place of the usual Dialer
* elements (the textfield/button and the dialpad underneath).
*
* We show this UI if the user brings up the Dialer while a call is
* already in progress, since there's a good chance we got here
* accidentally (and the user really wanted the in-call dialpad instead).
* So in this situation we display an intermediate UI that lets the user
* explicitly choose between the in-call dialpad ("Use touch tone
* keypad") and the regular Dialer ("Add call"). (Or, the option "Return
* to call in progress" just goes back to the in-call UI with no dialpad
* at all.)
*
* @param enabled If true, show the "dialpad chooser" instead
* of the regular Dialer UI
*/
private void showDialpadChooser(boolean enabled) {
// Check if onCreateView() is already called by checking one of View objects.
if (!isLayoutReady()) {
return;
}
if (enabled) {
// Log.i(TAG, "Showing dialpad chooser!");
if (mDigitsContainer != null) {
mDigitsContainer.setVisibility(View.GONE);
} else {
// mDigits is not enclosed by the container. Make the digits field itself gone.
mDigits.setVisibility(View.GONE);
}
if (mDialpad != null) mDialpad.setVisibility(View.GONE);
if (mDialButtonContainer != null) mDialButtonContainer.setVisibility(View.GONE);
mDialpadChooser.setVisibility(View.VISIBLE);
// Instantiate the DialpadChooserAdapter and hook it up to the
// ListView. We do this only once.
if (mDialpadChooserAdapter == null) {
mDialpadChooserAdapter = new DialpadChooserAdapter(getActivity());
}
mDialpadChooser.setAdapter(mDialpadChooserAdapter);
} else {
// Log.i(TAG, "Displaying normal Dialer UI.");
if (mDigitsContainer != null) {
mDigitsContainer.setVisibility(View.VISIBLE);
} else {
mDigits.setVisibility(View.VISIBLE);
}
if (mDialpad != null) mDialpad.setVisibility(View.VISIBLE);
if (mDialButtonContainer != null) mDialButtonContainer.setVisibility(View.VISIBLE);
mDialpadChooser.setVisibility(View.GONE);
}
}
/**
* @return true if we're currently showing the "dialpad chooser" UI.
*/
private boolean dialpadChooserVisible() {
return mDialpadChooser.getVisibility() == View.VISIBLE;
}
/**
* Simple list adapter, binding to an icon + text label
* for each item in the "dialpad chooser" list.
*/
private static class DialpadChooserAdapter extends BaseAdapter {
private LayoutInflater mInflater;
// Simple struct for a single "choice" item.
static class ChoiceItem {
String text;
Bitmap icon;
int id;
public ChoiceItem(String s, Bitmap b, int i) {
text = s;
icon = b;
id = i;
}
}
// IDs for the possible "choices":
static final int DIALPAD_CHOICE_USE_DTMF_DIALPAD = 101;
static final int DIALPAD_CHOICE_RETURN_TO_CALL = 102;
static final int DIALPAD_CHOICE_ADD_NEW_CALL = 103;
private static final int NUM_ITEMS = 3;
private ChoiceItem mChoiceItems[] = new ChoiceItem[NUM_ITEMS];
public DialpadChooserAdapter(Context context) {
// Cache the LayoutInflate to avoid asking for a new one each time.
mInflater = LayoutInflater.from(context);
// Initialize the possible choices.
// TODO: could this be specified entirely in XML?
// - "Use touch tone keypad"
mChoiceItems[0] = new ChoiceItem(
context.getString(R.string.dialer_useDtmfDialpad),
BitmapFactory.decodeResource(context.getResources(),
R.drawable.ic_dialer_fork_tt_keypad),
DIALPAD_CHOICE_USE_DTMF_DIALPAD);
// - "Return to call in progress"
mChoiceItems[1] = new ChoiceItem(
context.getString(R.string.dialer_returnToInCallScreen),
BitmapFactory.decodeResource(context.getResources(),
R.drawable.ic_dialer_fork_current_call),
DIALPAD_CHOICE_RETURN_TO_CALL);
// - "Add call"
mChoiceItems[2] = new ChoiceItem(
context.getString(R.string.dialer_addAnotherCall),
BitmapFactory.decodeResource(context.getResources(),
R.drawable.ic_dialer_fork_add_call),
DIALPAD_CHOICE_ADD_NEW_CALL);
}
@Override
public int getCount() {
return NUM_ITEMS;
}
/**
* Return the ChoiceItem for a given position.
*/
@Override
public Object getItem(int position) {
return mChoiceItems[position];
}
/**
* Return a unique ID for each possible choice.
*/
@Override
public long getItemId(int position) {
return position;
}
/**
* Make a view for each row.
*/
@Override
public View getView(int position, View convertView, ViewGroup parent) {
// When convertView is non-null, we can reuse it (there's no need
// to reinflate it.)
if (convertView == null) {
convertView = mInflater.inflate(R.layout.dialpad_chooser_list_item, null);
}
TextView text = (TextView) convertView.findViewById(R.id.text);
text.setText(mChoiceItems[position].text);
ImageView icon = (ImageView) convertView.findViewById(R.id.icon);
icon.setImageBitmap(mChoiceItems[position].icon);
return convertView;
}
}
/**
* Handle clicks from the dialpad chooser.
*/
@Override
public void onItemClick(AdapterView<?> parent, View v, int position, long id) {
DialpadChooserAdapter.ChoiceItem item =
(DialpadChooserAdapter.ChoiceItem) parent.getItemAtPosition(position);
int itemId = item.id;
switch (itemId) {
case DialpadChooserAdapter.DIALPAD_CHOICE_USE_DTMF_DIALPAD:
// Log.i(TAG, "DIALPAD_CHOICE_USE_DTMF_DIALPAD");
// Fire off an intent to go back to the in-call UI
// with the dialpad visible.
returnToInCallScreen(true);
break;
case DialpadChooserAdapter.DIALPAD_CHOICE_RETURN_TO_CALL:
// Log.i(TAG, "DIALPAD_CHOICE_RETURN_TO_CALL");
// Fire off an intent to go back to the in-call UI
// (with the dialpad hidden).
returnToInCallScreen(false);
break;
case DialpadChooserAdapter.DIALPAD_CHOICE_ADD_NEW_CALL:
// Log.i(TAG, "DIALPAD_CHOICE_ADD_NEW_CALL");
// Ok, guess the user really did want to be here (in the
// regular Dialer) after all. Bring back the normal Dialer UI.
showDialpadChooser(false);
break;
default:
Log.w(TAG, "onItemClick: unexpected itemId: " + itemId);
break;
}
}
/**
* Returns to the in-call UI (where there's presumably a call in
* progress) in response to the user selecting "use touch tone keypad"
* or "return to call" from the dialpad chooser.
*/
private void returnToInCallScreen(boolean showDialpad) {
try {
ITelephony phone = ITelephony.Stub.asInterface(ServiceManager.checkService("phone"));
if (phone != null) phone.showCallScreenWithDialpad(showDialpad);
} catch (RemoteException e) {
Log.w(TAG, "phone.showCallScreenWithDialpad() failed", e);
}
// Finally, finish() ourselves so that we don't stay on the
// activity stack.
// Note that we do this whether or not the showCallScreenWithDialpad()
// call above had any effect or not! (That call is a no-op if the
// phone is idle, which can happen if the current call ends while
// the dialpad chooser is up. In this case we can't show the
// InCallScreen, and there's no point staying here in the Dialer,
// so we just take the user back where he came from...)
getActivity().finish();
}
/**
* @return true if the phone is "in use", meaning that at least one line
* is active (ie. off hook or ringing or dialing).
*/
public static boolean phoneIsInUse() {
boolean phoneInUse = false;
try {
ITelephony phone = ITelephony.Stub.asInterface(ServiceManager.checkService("phone"));
if (phone != null) phoneInUse = !phone.isIdle();
} catch (RemoteException e) {
Log.w(TAG, "phone.isIdle() failed", e);
}
return phoneInUse;
}
/**
* @return true if the phone is a CDMA phone type
*/
private boolean phoneIsCdma() {
boolean isCdma = false;
try {
ITelephony phone = ITelephony.Stub.asInterface(ServiceManager.checkService("phone"));
if (phone != null) {
isCdma = (phone.getActivePhoneType() == TelephonyManager.PHONE_TYPE_CDMA);
}
} catch (RemoteException e) {
Log.w(TAG, "phone.getActivePhoneType() failed", e);
}
return isCdma;
}
/**
* @return true if the phone state is OFFHOOK
*/
private boolean phoneIsOffhook() {
boolean phoneOffhook = false;
try {
ITelephony phone = ITelephony.Stub.asInterface(ServiceManager.checkService("phone"));
if (phone != null) phoneOffhook = phone.isOffhook();
} catch (RemoteException e) {
Log.w(TAG, "phone.isOffhook() failed", e);
}
return phoneOffhook;
}
/**
* Returns true whenever any one of the options from the menu is selected.
* Code changes to support dialpad options
*/
@Override
public boolean onOptionsItemSelected(MenuItem item) {
switch (item.getItemId()) {
case R.id.menu_2s_pause:
updateDialString(",");
return true;
case R.id.menu_add_wait:
updateDialString(";");
return true;
default:
return false;
}
}
@Override
public boolean onMenuItemClick(MenuItem item) {
return onOptionsItemSelected(item);
}
/**
* Updates the dial string (mDigits) after inserting a Pause character (,)
* or Wait character (;).
*/
private void updateDialString(String newDigits) {
int selectionStart;
int selectionEnd;
// SpannableStringBuilder editable_text = new SpannableStringBuilder(mDigits.getText());
int anchor = mDigits.getSelectionStart();
int point = mDigits.getSelectionEnd();
selectionStart = Math.min(anchor, point);
selectionEnd = Math.max(anchor, point);
Editable digits = mDigits.getText();
if (selectionStart != -1) {
if (selectionStart == selectionEnd) {
// then there is no selection. So insert the pause at this
// position and update the mDigits.
digits.replace(selectionStart, selectionStart, newDigits);
} else {
digits.replace(selectionStart, selectionEnd, newDigits);
// Unselect: back to a regular cursor, just pass the character inserted.
mDigits.setSelection(selectionStart + 1);
}
} else {
int len = mDigits.length();
digits.replace(len, len, newDigits);
}
}
/**
* Update the enabledness of the "Dial" and "Backspace" buttons if applicable.
*/
private void updateDialAndDeleteButtonEnabledState() {
final boolean digitsNotEmpty = !isDigitsEmpty();
if (mDialButton != null) {
// On CDMA phones, if we're already on a call, we *always*
// enable the Dial button (since you can press it without
// entering any digits to send an empty flash.)
if (phoneIsCdma() && phoneIsOffhook()) {
mDialButton.setEnabled(true);
} else {
// Common case: GSM, or CDMA but not on a call.
// Enable the Dial button if some digits have
// been entered, or if there is a last dialed number
// that could be redialed.
mDialButton.setEnabled(digitsNotEmpty ||
!TextUtils.isEmpty(mLastNumberDialed));
}
}
mDelete.setEnabled(digitsNotEmpty);
}
/**
* Check if voicemail is enabled/accessible.
*
* @return true if voicemail is enabled and accessibly. Note that this can be false
* "temporarily" after the app boot.
* @see TelephonyManager#getVoiceMailNumber()
*/
private boolean isVoicemailAvailable() {
try {
return (TelephonyManager.getDefault().getVoiceMailNumber() != null);
} catch (SecurityException se) {
// Possibly no READ_PHONE_STATE privilege.
Log.w(TAG, "SecurityException is thrown. Maybe privilege isn't sufficient.");
}
return false;
}
/**
* This function return true if Wait menu item can be shown
* otherwise returns false. Assumes the passed string is non-empty
* and the 0th index check is not required.
*/
private static boolean showWait(int start, int end, String digits) {
if (start == end) {
// visible false in this case
if (start > digits.length()) return false;
// preceding char is ';', so visible should be false
if (digits.charAt(start - 1) == ';') return false;
// next char is ';', so visible should be false
if ((digits.length() > start) && (digits.charAt(start) == ';')) return false;
} else {
// visible false in this case
if (start > digits.length() || end > digits.length()) return false;
// In this case we need to just check for ';' preceding to start
// or next to end
if (digits.charAt(start - 1) == ';') return false;
}
return true;
}
/**
* @return true if the widget with the phone number digits is empty.
*/
private boolean isDigitsEmpty() {
return mDigits.length() == 0;
}
/**
* Starts the asyn query to get the last dialed/outgoing
* number. When the background query finishes, mLastNumberDialed
* is set to the last dialed number or an empty string if none
* exists yet.
*/
private void queryLastOutgoingCall() {
mLastNumberDialed = EMPTY_NUMBER;
CallLogAsync.GetLastOutgoingCallArgs lastCallArgs =
new CallLogAsync.GetLastOutgoingCallArgs(
getActivity(),
new CallLogAsync.OnLastOutgoingCallComplete() {
@Override
public void lastOutgoingCall(String number) {
// TODO: Filter out emergency numbers if
// the carrier does not want redial for
// these.
mLastNumberDialed = number;
updateDialAndDeleteButtonEnabledState();
}
});
mCallLog.getLastOutgoingCall(lastCallArgs);
}
private Intent newFlashIntent() {
final Intent intent = CallUtil.getCallIntent(EMPTY_NUMBER);
intent.putExtra(EXTRA_SEND_EMPTY_FLASH, true);
return intent;
}
}