/*
* 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.dialpadview;
import android.annotation.TargetApi;
import android.app.Activity;
import android.app.AlertDialog;
import android.app.Dialog;
import android.app.DialogFragment;
import android.app.Fragment;
import android.content.BroadcastReceiver;
import android.content.ContentResolver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.res.Configuration;
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.Build.VERSION;
import android.os.Build.VERSION_CODES;
import android.os.Bundle;
import android.os.PersistableBundle;
import android.os.Trace;
import android.provider.Contacts.People;
import android.provider.Contacts.Phones;
import android.provider.Contacts.PhonesColumns;
import android.provider.Settings;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
import android.support.annotation.VisibleForTesting;
import android.support.design.widget.FloatingActionButton;
import android.telecom.PhoneAccount;
import android.telecom.PhoneAccountHandle;
import android.telephony.PhoneNumberFormattingTextWatcher;
import android.telephony.PhoneNumberUtils;
import android.telephony.ServiceState;
import android.telephony.TelephonyManager;
import android.text.Editable;
import android.text.Selection;
import android.text.TextUtils;
import android.text.TextWatcher;
import android.util.AttributeSet;
import android.view.HapticFeedbackConstants;
import android.view.KeyEvent;
import android.view.LayoutInflater;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.view.ViewGroup;
import android.view.animation.Animation;
import android.view.animation.Animation.AnimationListener;
import android.view.animation.AnimationUtils;
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.RelativeLayout;
import android.widget.TextView;
import com.android.contacts.common.dialog.CallSubjectDialog;
import com.android.contacts.common.util.StopWatch;
import com.android.dialer.animation.AnimUtils;
import com.android.dialer.animation.AnimUtils.AnimationCallback;
import com.android.dialer.callintent.CallInitiationType;
import com.android.dialer.callintent.CallIntentBuilder;
import com.android.dialer.common.Assert;
import com.android.dialer.common.FragmentUtils;
import com.android.dialer.common.LogUtil;
import com.android.dialer.common.concurrent.DialerExecutor;
import com.android.dialer.common.concurrent.DialerExecutor.Worker;
import com.android.dialer.common.concurrent.DialerExecutorComponent;
import com.android.dialer.location.GeoUtil;
import com.android.dialer.logging.UiAction;
import com.android.dialer.oem.MotorolaUtils;
import com.android.dialer.performancereport.PerformanceReport;
import com.android.dialer.phonenumberutil.PhoneNumberHelper;
import com.android.dialer.precall.PreCall;
import com.android.dialer.proguard.UsedByReflection;
import com.android.dialer.telecom.TelecomUtil;
import com.android.dialer.util.CallUtil;
import com.android.dialer.util.PermissionsUtil;
import com.android.dialer.util.ViewUtil;
import com.android.dialer.widget.FloatingActionButtonController;
import com.google.common.base.Ascii;
import com.google.common.base.Optional;
import java.util.HashSet;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/** 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,
DialpadKeyButton.OnPressedListener {
private static final String TAG = "DialpadFragment";
private static final String EMPTY_NUMBER = "";
private static final char PAUSE = ',';
private static final char WAIT = ';';
/** 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;
/** 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".
*
* <p>TODO: Using an intent extra to tell the phone to send this flash is a temporary measure. To
* be replaced with an Telephony/TelecomManager call in the future. TODO: Keep in sync with the
* string defined in OutgoingCallBroadcaster.java in Phone app until this is replaced with the
* Telephony/Telecom API.
*/
private static final String EXTRA_SEND_EMPTY_FLASH = "com.android.phone.extra.SEND_EMPTY_FLASH";
private static final String PREF_DIGITS_FILLED_BY_INTENT = "pref_digits_filled_by_intent";
private static final String PREF_IS_DIALPAD_SLIDE_OUT = "pref_is_dialpad_slide_out";
/**
* Hidden key in carrier config to determine if no emergency call over wifi warning is required.
*
* <p>"Time delay (in ms) after which we show the notification for emergency calls, while the
* device is registered over WFC. Default value is -1, which indicates that this notification is
* not pertinent for a particular carrier. We've added a delay to prevent false positives."
*/
@VisibleForTesting
static final String KEY_EMERGENCY_NOTIFICATION_DELAY_INT = "emergency_notification_delay_int";
private static Optional<String> currentCountryIsoForTesting = Optional.absent();
private static Boolean showEmergencyCallWarningForTest = null;
private final Object toneGeneratorLock = new Object();
/** Set of dialpad keys that are currently being pressed */
private final HashSet<View> pressedDialpadKeys = new HashSet<>(12);
private OnDialpadQueryChangedListener dialpadQueryListener;
private DialpadView dialpadView;
private EditText digits;
private TextView digitsHint;
private int dialpadSlideInDuration;
/** Remembers if we need to clear digits field when the screen is completely gone. */
private boolean clearDigitsOnStop;
private View overflowMenuButton;
private PopupMenu overflowPopupMenu;
private View delete;
private ToneGenerator toneGenerator;
private FloatingActionButtonController floatingActionButtonController;
private FloatingActionButton floatingActionButton;
private ListView dialpadChooser;
private DialpadChooserAdapter dialpadChooserAdapter;
/** Regular expression prohibiting manual phone call. Can be empty, which means "no rule". */
private String prohibitedPhoneNumberRegexp;
private PseudoEmergencyAnimator pseudoEmergencyAnimator;
private String lastNumberDialed = EMPTY_NUMBER;
// determines if we want to playback local DTMF tones.
private boolean dTMFToneEnabled;
private CallStateReceiver callStateReceiver;
private boolean wasEmptyBeforeTextChange;
/**
* 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 digitsFilledByIntent;
private boolean startedFromNewIntent = false;
private boolean firstLaunch = false;
private boolean animate = false;
private boolean isLayoutRtl;
private boolean isLandscape;
private DialerExecutor<String> initPhoneNumberFormattingTextWatcherExecutor;
private boolean isDialpadSlideUp;
/**
* Determines whether an add call operation is requested.
*
* @param intent The intent.
* @return {@literal true} if add call operation was requested. {@literal false} otherwise.
*/
public static boolean isAddCallMode(Intent intent) {
if (intent == null) {
return false;
}
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;
}
}
/**
* Format the provided string of digits into one that represents a properly formatted phone
* number.
*
* @param dialString String of characters to format
* @param normalizedNumber the E164 format number whose country code is used if the given
* phoneNumber doesn't have the country code.
* @param countryIso The country code representing the format to use if the provided normalized
* number is null or invalid.
* @return the provided string of digits as a formatted phone number, retaining any post-dial
* portion of the string.
*/
String getFormattedDigits(String dialString, String normalizedNumber, String countryIso) {
String number = PhoneNumberUtils.extractNetworkPortion(dialString);
// Also retrieve the post dial portion of the provided data, so that the entire dial
// string can be reconstituted later.
final String postDial = PhoneNumberUtils.extractPostDialPortion(dialString);
if (TextUtils.isEmpty(number)) {
return postDial;
}
number = PhoneNumberHelper.formatNumber(getContext(), number, normalizedNumber, countryIso);
if (TextUtils.isEmpty(postDial)) {
return number;
}
return number.concat(postDial);
}
/**
* Returns true of the newDigit parameter can be added at the current selection point, otherwise
* returns false. Only prevents input of WAIT and PAUSE digits at an unsupported position. Fails
* early if start == -1 or start is larger than end.
*/
@VisibleForTesting
/* package */ static boolean canAddDigit(CharSequence digits, int start, int end, char newDigit) {
if (newDigit != WAIT && newDigit != PAUSE) {
throw new IllegalArgumentException(
"Should not be called for anything other than PAUSE & WAIT");
}
// False if no selection, or selection is reversed (end < start)
if (start == -1 || end < start) {
return false;
}
// unsupported selection-out-of-bounds state
if (start > digits.length() || end > digits.length()) {
return false;
}
// Special digit cannot be the first digit
if (start == 0) {
return false;
}
if (newDigit == WAIT) {
// preceding char is ';' (WAIT)
if (digits.charAt(start - 1) == WAIT) {
return false;
}
// next char is ';' (WAIT)
if ((digits.length() > end) && (digits.charAt(end) == WAIT)) {
return false;
}
}
return true;
}
private TelephonyManager getTelephonyManager() {
return (TelephonyManager) getActivity().getSystemService(Context.TELEPHONY_SERVICE);
}
@Override
public Context getContext() {
return getActivity();
}
@Override
public void beforeTextChanged(CharSequence s, int start, int count, int after) {
wasEmptyBeforeTextChange = TextUtils.isEmpty(s);
}
@Override
public void onTextChanged(CharSequence input, int start, int before, int changeCount) {
if (wasEmptyBeforeTextChange != TextUtils.isEmpty(input)) {
final Activity activity = getActivity();
if (activity != null) {
activity.invalidateOptionsMenu();
updateMenuOverflowButton(wasEmptyBeforeTextChange);
}
updateDialpadHint();
}
// 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 SpecialCharSequenceMgr sequence,
// since some of SpecialCharSequenceMgr's behavior is too abrupt for the "touch-down"
// behavior.
if (!digitsFilledByIntent
&& SpecialCharSequenceMgr.handleChars(getActivity(), input.toString(), digits)) {
// A special sequence was entered, clear the digits
digits.getText().clear();
}
if (isDigitsEmpty()) {
digitsFilledByIntent = false;
digits.setCursorVisible(false);
}
if (dialpadQueryListener != null) {
dialpadQueryListener.onDialpadQueryChanged(digits.getText().toString());
}
updateDeleteButtonEnabledState();
}
@Override
public void onCreate(Bundle state) {
Trace.beginSection(TAG + " onCreate");
LogUtil.enterBlock("DialpadFragment.onCreate");
super.onCreate(state);
firstLaunch = state == null;
prohibitedPhoneNumberRegexp =
getResources().getString(R.string.config_prohibited_phone_number_regexp);
if (state != null) {
digitsFilledByIntent = state.getBoolean(PREF_DIGITS_FILLED_BY_INTENT);
isDialpadSlideUp = state.getBoolean(PREF_IS_DIALPAD_SLIDE_OUT);
}
dialpadSlideInDuration = getResources().getInteger(R.integer.dialpad_slide_in_duration);
if (callStateReceiver == null) {
IntentFilter callStateIntentFilter =
new IntentFilter(TelephonyManager.ACTION_PHONE_STATE_CHANGED);
callStateReceiver = new CallStateReceiver();
getActivity().registerReceiver(callStateReceiver, callStateIntentFilter);
}
initPhoneNumberFormattingTextWatcherExecutor =
DialerExecutorComponent.get(getContext())
.dialerExecutorFactory()
.createUiTaskBuilder(
getFragmentManager(),
"DialpadFragment.initPhoneNumberFormattingTextWatcher",
new InitPhoneNumberFormattingTextWatcherWorker())
.onSuccess(watcher -> dialpadView.getDigits().addTextChangedListener(watcher))
.build();
Trace.endSection();
}
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedState) {
Trace.beginSection(TAG + " onCreateView");
LogUtil.enterBlock("DialpadFragment.onCreateView");
Trace.beginSection(TAG + " inflate view");
View fragmentView = inflater.inflate(R.layout.dialpad_fragment, container, false);
Trace.endSection();
Trace.beginSection(TAG + " buildLayer");
fragmentView.buildLayer();
Trace.endSection();
Trace.beginSection(TAG + " setup views");
dialpadView = fragmentView.findViewById(R.id.dialpad_view);
dialpadView.setCanDigitsBeEdited(true);
digits = dialpadView.getDigits();
digitsHint = dialpadView.getDigitsHint();
digits.setKeyListener(UnicodeDialerKeyListener.INSTANCE);
digits.setOnClickListener(this);
digits.setOnKeyListener(this);
digits.setOnLongClickListener(this);
digits.addTextChangedListener(this);
digits.setElegantTextHeight(false);
if (!MotorolaUtils.shouldDisablePhoneNumberFormatting(getContext())) {
initPhoneNumberFormattingTextWatcherExecutor.executeSerial(getCurrentCountryIso());
}
// Check for the presence of the keypad
View oneButton = fragmentView.findViewById(R.id.one);
if (oneButton != null) {
configureKeypadListeners(fragmentView);
}
delete = dialpadView.getDeleteButton();
if (delete != null) {
delete.setOnClickListener(this);
delete.setOnLongClickListener(this);
}
fragmentView
.findViewById(R.id.spacer)
.setOnTouchListener(
(v, event) -> {
if (isDigitsEmpty()) {
if (getActivity() != null) {
LogUtil.i("DialpadFragment.onCreateView", "dialpad spacer touched");
return FragmentUtils.getParentUnsafe(this, HostInterface.class)
.onDialpadSpacerTouchWithEmptyQuery();
}
return true;
}
return false;
});
digits.setCursorVisible(false);
// Set up the "dialpad chooser" UI; see showDialpadChooser().
dialpadChooser = fragmentView.findViewById(R.id.dialpadChooser);
dialpadChooser.setOnItemClickListener(this);
floatingActionButton = fragmentView.findViewById(R.id.dialpad_floating_action_button);
floatingActionButton.setOnClickListener(this);
floatingActionButtonController =
new FloatingActionButtonController(getActivity(), floatingActionButton);
Trace.endSection();
Trace.endSection();
return fragmentView;
}
/**
* The dialpad hint is a TextView overlaid above the digit EditText. {@link EditText#setHint(int)}
* is not used because the digits has auto resize and makes setting the size of the hint
* difficult.
*/
private void updateDialpadHint() {
if (!TextUtils.isEmpty(digits.getText())) {
digitsHint.setVisibility(View.GONE);
return;
}
if (shouldShowEmergencyCallWarning(getContext())) {
String hint = getContext().getString(R.string.dialpad_hint_emergency_calling_not_available);
digits.setContentDescription(hint);
digitsHint.setText(hint);
digitsHint.setVisibility(View.VISIBLE);
return;
}
digits.setContentDescription(null);
digitsHint.setVisibility(View.GONE);
}
/**
* Only show the "emergency call not available" warning when on wifi call and carrier requires it.
*
* <p>internal method tested because the conditions cannot be setup in espresso, and the layout
* cannot be inflated in robolectric.
*/
@SuppressWarnings("missingPermission")
@TargetApi(VERSION_CODES.O)
@VisibleForTesting
static boolean shouldShowEmergencyCallWarning(Context context) {
if (showEmergencyCallWarningForTest != null) {
return showEmergencyCallWarningForTest;
}
if (VERSION.SDK_INT < VERSION_CODES.O) {
return false;
}
if (!PermissionsUtil.hasReadPhoneStatePermissions(context)) {
return false;
}
TelephonyManager telephonyManager = context.getSystemService(TelephonyManager.class);
PersistableBundle config = telephonyManager.getCarrierConfig();
// A delay of -1 means wifi emergency call is available/the warning is not required.
if (config == null || config.getInt(KEY_EMERGENCY_NOTIFICATION_DELAY_INT, -1) == -1) {
return false;
}
// TelephonyManager.getVoiceNetworkType() Doesn't always return NETWORK_TYPE_IWLAN when on wifi.
// other wifi calling checks are hidden API. Emergency calling is not available without service
// regardless of the wifi state so this check is omitted.
switch (telephonyManager.getServiceState().getState()) {
case ServiceState.STATE_OUT_OF_SERVICE:
case ServiceState.STATE_POWER_OFF:
return true;
case ServiceState.STATE_EMERGENCY_ONLY:
case ServiceState.STATE_IN_SERVICE:
return false;
default:
throw new AssertionError("unknown state " + telephonyManager.getServiceState().getState());
}
}
@VisibleForTesting
static void setShowEmergencyCallWarningForTest(Boolean value) {
showEmergencyCallWarningForTest = value;
}
@Override
public void onAttach(Context context) {
super.onAttach(context);
isLayoutRtl = ViewUtil.isRtl();
isLandscape =
getResources().getConfiguration().orientation == Configuration.ORIENTATION_LANDSCAPE;
}
private String getCurrentCountryIso() {
if (currentCountryIsoForTesting.isPresent()) {
return currentCountryIsoForTesting.get();
}
return GeoUtil.getCurrentCountryIso(getActivity());
}
@VisibleForTesting(otherwise = VisibleForTesting.NONE)
public static void setCurrentCountryIsoForTesting(String countryCode) {
currentCountryIsoForTesting = Optional.of(countryCode);
}
private boolean isLayoutReady() {
return digits != null;
}
public EditText getDigitsWidget() {
return digits;
}
/** @return true when {@link #digits} is actually filled by the Intent. */
private boolean fillDigitsIfNecessary(Intent intent) {
// Only fills digits from an intent if it is a new intent.
// Otherwise falls back to the previously used number.
if (!firstLaunch && !startedFromNewIntent) {
return false;
}
final String action = intent.getAction();
if (Intent.ACTION_DIAL.equals(action) || Intent.ACTION_VIEW.equals(action)) {
Uri uri = intent.getData();
if (uri != null) {
if (PhoneAccount.SCHEME_TEL.equals(uri.getScheme())) {
// Put the requested number into the input area
String data = uri.getSchemeSpecificPart();
// Remember it is filled via Intent.
digitsFilledByIntent = true;
final String converted =
PhoneNumberUtils.convertKeypadLettersToDigits(
PhoneNumberUtils.replaceUnicodeDigits(data));
setFormattedDigits(converted, null);
return true;
} else {
if (!PermissionsUtil.hasContactsReadPermissions(getActivity())) {
return false;
}
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.
digitsFilledByIntent = true;
// Put the number into the input area
setFormattedDigits(c.getString(0), c.getString(1));
return true;
}
} finally {
c.close();
}
}
}
}
}
}
return false;
}
/**
* Checks the given Intent and changes dialpad's UI state.
*
* <p>There are three modes:
*
* <ul>
* <li>Empty Dialpad shown via "Add Call" in the in call ui
* <li>Dialpad (digits filled), shown by {@link Intent#ACTION_DIAL} with a number.
* <li>Return to call view, shown when a call is ongoing without {@link Intent#ACTION_DIAL}
* </ul>
*
* For example, if the user...
*
* <ul>
* <li>clicks a number in gmail, this method will show the dialpad filled with the number,
* regardless of whether a call is ongoing.
* <li>places a call, presses home and opens dialer, this method will show the return to call
* prompt to confirm what they want to do.
* </ul>
*/
private void configureScreenFromIntent(@NonNull Intent intent) {
LogUtil.i("DialpadFragment.configureScreenFromIntent", "action: %s", intent.getAction());
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.
LogUtil.i(
"DialpadFragment.configureScreenFromIntent",
"Screen configuration is requested before onCreateView() is called. Ignored");
return;
}
// If "Add call" was selected, show the dialpad instead of the dialpad chooser prompt
if (isAddCallMode(intent)) {
LogUtil.i("DialpadFragment.configureScreenFromIntent", "Add call mode");
showDialpadChooser(false);
setStartedFromNewIntent(true);
return;
}
// Don't show the chooser when called via onNewIntent() and phone number is present.
// i.e. User clicks a telephone link from gmail for example.
// In this case, we want to show the dialpad with the phone number.
boolean digitsFilled = fillDigitsIfNecessary(intent);
if (!(startedFromNewIntent && digitsFilled) && isPhoneInUse()) {
// If there's already an active call, bring up an intermediate UI to
// make the user confirm what they really want to do.
LogUtil.i("DialpadFragment.configureScreenFromIntent", "Dialpad chooser mode");
showDialpadChooser(true);
setStartedFromNewIntent(false);
return;
}
LogUtil.i("DialpadFragment.configureScreenFromIntent", "Nothing to show");
showDialpadChooser(false);
setStartedFromNewIntent(false);
}
public void setStartedFromNewIntent(boolean value) {
startedFromNewIntent = value;
}
public void clearCallRateInformation() {
setCallRateInformation(null, null);
}
public void setCallRateInformation(String countryName, String displayRate) {
dialpadView.setCallRateInformation(countryName, displayRate);
}
/** Sets formatted digits to digits field. */
private void setFormattedDigits(String data, String normalizedNumber) {
final String formatted = getFormattedDigits(data, normalizedNumber, getCurrentCountryIso());
if (!TextUtils.isEmpty(formatted)) {
Editable digits = this.digits.getText();
digits.replace(0, digits.length(), formatted);
// 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 configureKeypadListeners(View fragmentView) {
final 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.star,
R.id.zero,
R.id.pound
};
DialpadKeyButton dialpadKey;
for (int buttonId : buttonIds) {
dialpadKey = fragmentView.findViewById(buttonId);
dialpadKey.setOnPressedListener(this);
}
// Long-pressing one button will initiate Voicemail.
final DialpadKeyButton one = fragmentView.findViewById(R.id.one);
one.setOnLongClickListener(this);
// Long-pressing zero button will enter '+' instead.
final DialpadKeyButton zero = fragmentView.findViewById(R.id.zero);
zero.setOnLongClickListener(this);
}
@Override
public void onStart() {
LogUtil.i("DialpadFragment.onStart", "first launch: %b", firstLaunch);
Trace.beginSection(TAG + " onStart");
super.onStart();
Resources res = getResources();
int iconId = R.drawable.quantum_ic_call_vd_theme_24;
if (MotorolaUtils.isWifiCallingAvailable(getContext())) {
iconId = R.drawable.ic_wifi_calling;
}
floatingActionButtonController.changeIcon(
getContext(), iconId, res.getString(R.string.description_dial_button));
// 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.
final long start = System.currentTimeMillis();
synchronized (toneGeneratorLock) {
if (toneGenerator == null) {
try {
toneGenerator = new ToneGenerator(DIAL_TONE_STREAM_TYPE, TONE_RELATIVE_VOLUME);
} catch (RuntimeException e) {
LogUtil.e(
"DialpadFragment.onStart",
"Exception caught while creating local tone generator: " + e);
toneGenerator = null;
}
}
}
final long total = System.currentTimeMillis() - start;
if (total > 50) {
LogUtil.i("DialpadFragment.onStart", "Time for ToneGenerator creation: " + total);
}
Trace.endSection();
}
@Override
public void onResume() {
LogUtil.enterBlock("DialpadFragment.onResume");
Trace.beginSection(TAG + " onResume");
super.onResume();
dialpadQueryListener = FragmentUtils.getParentUnsafe(this, OnDialpadQueryChangedListener.class);
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");
final ContentResolver contentResolver = getActivity().getContentResolver();
// retrieve the DTMF tone play back setting.
dTMFToneEnabled =
Settings.System.getInt(contentResolver, Settings.System.DTMF_TONE_WHEN_DIALING, 1) == 1;
stopWatch.lap("dtwd");
stopWatch.lap("hptc");
pressedDialpadKeys.clear();
configureScreenFromIntent(getActivity().getIntent());
stopWatch.lap("fdin");
if (!isPhoneInUse()) {
LogUtil.i("DialpadFragment.onResume", "phone not in use");
// A sanity-check: the "dialpad chooser" UI should not be visible if the phone is idle.
showDialpadChooser(false);
}
stopWatch.lap("hnt");
updateDeleteButtonEnabledState();
stopWatch.lap("bes");
stopWatch.stopAndLog(TAG, 50);
// Populate the overflow menu in onResume instead of onCreate, so that if the SMS activity
// is disabled while Dialer is paused, the "Send a text message" option can be correctly
// removed when resumed.
overflowMenuButton = dialpadView.getOverflowMenuButton();
overflowPopupMenu = buildOptionsMenu(overflowMenuButton);
overflowMenuButton.setOnTouchListener(overflowPopupMenu.getDragToOpenListener());
overflowMenuButton.setOnClickListener(this);
overflowMenuButton.setVisibility(isDigitsEmpty() ? View.INVISIBLE : View.VISIBLE);
updateDialpadHint();
if (firstLaunch) {
// The onHiddenChanged callback does not get called the first time the fragment is
// attached, so call it ourselves here.
onHiddenChanged(false);
}
firstLaunch = false;
Trace.endSection();
}
@Override
public void onPause() {
super.onPause();
// Make sure we don't leave this activity with a tone still playing.
stopTone();
pressedDialpadKeys.clear();
// TODO: I wonder if we should not check if the AsyncTask that
// lookup the last dialed number has completed.
lastNumberDialed = EMPTY_NUMBER; // Since we are going to query again, free stale number.
SpecialCharSequenceMgr.cleanup();
overflowPopupMenu.dismiss();
}
@Override
public void onStop() {
LogUtil.enterBlock("DialpadFragment.onStop");
super.onStop();
floatingActionButtonController.scaleOut();
synchronized (toneGeneratorLock) {
if (toneGenerator != null) {
toneGenerator.release();
toneGenerator = null;
}
}
if (clearDigitsOnStop) {
clearDigitsOnStop = false;
clearDialpad();
}
}
@Override
public void onSaveInstanceState(Bundle outState) {
super.onSaveInstanceState(outState);
outState.putBoolean(PREF_DIGITS_FILLED_BY_INTENT, digitsFilledByIntent);
outState.putBoolean(PREF_IS_DIALPAD_SLIDE_OUT, isDialpadSlideUp);
}
@Override
public void onDestroy() {
super.onDestroy();
if (pseudoEmergencyAnimator != null) {
pseudoEmergencyAnimator.destroy();
pseudoEmergencyAnimator = null;
}
getActivity().unregisterReceiver(callStateReceiver);
}
private void keyPressed(int keyCode) {
if (getView() == null || getView().getTranslationY() != 0) {
return;
}
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;
}
getView().performHapticFeedback(HapticFeedbackConstants.VIRTUAL_KEY);
KeyEvent event = new KeyEvent(KeyEvent.ACTION_DOWN, keyCode);
digits.onKeyDown(keyCode, event);
// If the cursor is at the end of the text we hide it.
final int length = digits.length();
if (length == digits.getSelectionStart() && length == digits.getSelectionEnd()) {
digits.setCursorVisible(false);
}
}
@Override
public boolean onKey(View view, int keyCode, KeyEvent event) {
if (view.getId() == R.id.digits) {
if (keyCode == KeyEvent.KEYCODE_ENTER) {
handleDialButtonPressed();
return true;
}
}
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 (pressed) {
int resId = view.getId();
if (resId == R.id.one) {
keyPressed(KeyEvent.KEYCODE_1);
} else if (resId == R.id.two) {
keyPressed(KeyEvent.KEYCODE_2);
} else if (resId == R.id.three) {
keyPressed(KeyEvent.KEYCODE_3);
} else if (resId == R.id.four) {
keyPressed(KeyEvent.KEYCODE_4);
} else if (resId == R.id.five) {
keyPressed(KeyEvent.KEYCODE_5);
} else if (resId == R.id.six) {
keyPressed(KeyEvent.KEYCODE_6);
} else if (resId == R.id.seven) {
keyPressed(KeyEvent.KEYCODE_7);
} else if (resId == R.id.eight) {
keyPressed(KeyEvent.KEYCODE_8);
} else if (resId == R.id.nine) {
keyPressed(KeyEvent.KEYCODE_9);
} else if (resId == R.id.zero) {
keyPressed(KeyEvent.KEYCODE_0);
} else if (resId == R.id.pound) {
keyPressed(KeyEvent.KEYCODE_POUND);
} else if (resId == R.id.star) {
keyPressed(KeyEvent.KEYCODE_STAR);
} else {
LogUtil.e(
"DialpadFragment.onPressed", "Unexpected onTouch(ACTION_DOWN) event from: " + view);
}
pressedDialpadKeys.add(view);
} else {
pressedDialpadKeys.remove(view);
if (pressedDialpadKeys.isEmpty()) {
stopTone();
}
}
}
/**
* Called by the containing Activity to tell this Fragment to build an overflow options menu for
* display by the container when appropriate.
*
* @param invoker the View that invoked the options menu, to act as an anchor location.
*/
private PopupMenu buildOptionsMenu(View invoker) {
final PopupMenu popupMenu =
new PopupMenu(getActivity(), invoker) {
@Override
public void show() {
final Menu menu = getMenu();
boolean enable = !isDigitsEmpty();
for (int i = 0; i < menu.size(); i++) {
MenuItem item = menu.getItem(i);
item.setEnabled(enable);
if (item.getItemId() == R.id.menu_call_with_note) {
item.setVisible(CallUtil.isCallWithSubjectSupported(getContext()));
}
}
super.show();
}
};
popupMenu.inflate(R.menu.dialpad_options);
popupMenu.setOnMenuItemClickListener(this);
return popupMenu;
}
@Override
public void onClick(View view) {
int resId = view.getId();
if (resId == R.id.dialpad_floating_action_button) {
view.performHapticFeedback(HapticFeedbackConstants.VIRTUAL_KEY);
handleDialButtonPressed();
} else if (resId == R.id.deleteButton) {
keyPressed(KeyEvent.KEYCODE_DEL);
} else if (resId == R.id.digits) {
if (!isDigitsEmpty()) {
digits.setCursorVisible(true);
}
} else if (resId == R.id.dialpad_overflow) {
overflowPopupMenu.show();
} else {
LogUtil.w("DialpadFragment.onClick", "Unexpected event from: " + view);
}
}
@Override
public boolean onLongClick(View view) {
final Editable digits = this.digits.getText();
final int id = view.getId();
if (id == R.id.deleteButton) {
digits.clear();
return true;
} else if (id == R.id.one) {
// For non-talkback users: check for empty
// For linear navigation users: check for "1"
// For explore by touch users: check for "11"
if (isDigitsEmpty()
|| TextUtils.equals(this.digits.getText(), "1")
|| TextUtils.equals(this.digits.getText(), "11")) {
// We'll try to initiate voicemail and thus we want to remove irrelevant string.
removePreviousDigitIfPossible('1');
removePreviousDigitIfPossible('1');
List<PhoneAccountHandle> subscriptionAccountHandles =
TelecomUtil.getSubscriptionPhoneAccounts(getActivity());
boolean hasUserSelectedDefault =
subscriptionAccountHandles.contains(
TelecomUtil.getDefaultOutgoingPhoneAccount(
getActivity(), PhoneAccount.SCHEME_VOICEMAIL));
boolean needsAccountDisambiguation =
subscriptionAccountHandles.size() > 1 && !hasUserSelectedDefault;
if (needsAccountDisambiguation || isVoicemailAvailable()) {
// On a multi-SIM phone, if the user has not selected a default
// subscription, initiate a call to voicemail so they can select an account
// from the "Call with" dialog.
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;
} else if (id == R.id.zero) {
if (pressedDialpadKeys.contains(view)) {
// If the zero key is currently pressed, then the long press occurred by touch
// (and not via other means like certain accessibility input methods).
// Remove the '0' that was input when the key was first pressed.
removePreviousDigitIfPossible('0');
removePreviousDigitIfPossible('0');
}
keyPressed(KeyEvent.KEYCODE_PLUS);
stopTone();
pressedDialpadKeys.remove(view);
return true;
} else if (id == R.id.digits) {
this.digits.setCursorVisible(true);
return false;
}
return false;
}
/**
* Remove the digit just before the current position of the cursor, iff the following conditions
* are true: 1) The cursor is not positioned at index 0. 2) The digit before the current cursor
* position matches the current digit.
*
* @param digit to remove from the digits view.
*/
private void removePreviousDigitIfPossible(char digit) {
final int currentPosition = digits.getSelectionStart();
if (currentPosition > 0 && digit == digits.getText().charAt(currentPosition - 1)) {
digits.setSelection(currentPosition);
digits.getText().delete(currentPosition - 1, currentPosition);
}
}
public void callVoicemail() {
PreCall.start(
getContext(), CallIntentBuilder.forVoicemail(null, CallInitiationType.Type.DIALPAD));
hideAndClearDialpad();
}
private void hideAndClearDialpad() {
LogUtil.enterBlock("DialpadFragment.hideAndClearDialpad");
FragmentUtils.getParentUnsafe(this, DialpadListener.class).onCallPlacedFromDialpad();
}
/**
* 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.
*
* <p>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.)
*
* <p>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).
*/
private void handleDialButtonPressed() {
if (isDigitsEmpty()) { // No number entered.
// No real call made, so treat it as a click
PerformanceReport.recordClick(UiAction.Type.PRESS_CALL_BUTTON_WITHOUT_CALLING);
handleDialButtonClickWithEmptyDigits();
} else {
final String number = digits.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(prohibitedPhoneNumberRegexp)
&& number.matches(prohibitedPhoneNumberRegexp)) {
PerformanceReport.recordClick(UiAction.Type.PRESS_CALL_BUTTON_WITHOUT_CALLING);
LogUtil.i(
"DialpadFragment.handleDialButtonPressed",
"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.
clearDialpad();
} else {
PreCall.start(getContext(), new CallIntentBuilder(number, CallInitiationType.Type.DIALPAD));
hideAndClearDialpad();
}
}
}
public void clearDialpad() {
if (digits != null) {
digits.getText().clear();
}
}
private void handleDialButtonClickWithEmptyDigits() {
if (phoneIsCdma() && isPhoneInUse()) {
// TODO: Move this logic into services/Telephony
//
// 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(lastNumberDialed)) {
// Dialpad will be filled with last called number,
// but we don't want to record it as user action
PerformanceReport.setIgnoreActionOnce(UiAction.Type.TEXT_CHANGE_WITH_INPUT);
// Recall the last number dialed.
digits.setText(lastNumberDialed);
// ...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.
digits.setSelection(digits.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
*
* <p>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.
*
* <p>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 (!dTMFToneEnabled) {
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 (toneGeneratorLock) {
if (toneGenerator == null) {
LogUtil.w("DialpadFragment.playTone", "mToneGenerator == null, tone: " + tone);
return;
}
// Start the new tone (will stop any playing tone)
toneGenerator.startTone(tone, durationMs);
}
}
/** Stop the tone if it is played. */
private void stopTone() {
// if local tone playback is disabled, just return.
if (!dTMFToneEnabled) {
return;
}
synchronized (toneGeneratorLock) {
if (toneGenerator == null) {
LogUtil.w("DialpadFragment.stopTone", "mToneGenerator == null");
return;
}
toneGenerator.stopTone();
}
}
/**
* Brings up the "dialpad chooser" UI in place of the usual Dialer elements (the textfield/button
* and the dialpad underneath).
*
* <p>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) {
if (getActivity() == null) {
return;
}
// Check if onCreateView() is already called by checking one of View objects.
if (!isLayoutReady()) {
return;
}
if (enabled) {
LogUtil.i("DialpadFragment.showDialpadChooser", "Showing dialpad chooser!");
if (dialpadView != null) {
dialpadView.setVisibility(View.GONE);
}
if (overflowPopupMenu != null) {
overflowPopupMenu.dismiss();
}
floatingActionButtonController.scaleOut();
dialpadChooser.setVisibility(View.VISIBLE);
// Instantiate the DialpadChooserAdapter and hook it up to the
// ListView. We do this only once.
if (dialpadChooserAdapter == null) {
dialpadChooserAdapter = new DialpadChooserAdapter(getActivity());
}
dialpadChooser.setAdapter(dialpadChooserAdapter);
} else {
LogUtil.i("DialpadFragment.showDialpadChooser", "Displaying normal Dialer UI.");
if (dialpadView != null) {
LogUtil.i("DialpadFragment.showDialpadChooser", "mDialpadView not null");
dialpadView.setVisibility(View.VISIBLE);
if (isDialpadSlideUp()) {
floatingActionButtonController.scaleIn();
}
} else {
LogUtil.i("DialpadFragment.showDialpadChooser", "mDialpadView null");
digits.setVisibility(View.VISIBLE);
}
dialpadChooser.setVisibility(View.GONE);
}
}
/** @return true if we're currently showing the "dialpad chooser" UI. */
private boolean isDialpadChooserVisible() {
return dialpadChooser.getVisibility() == View.VISIBLE;
}
/** 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;
if (itemId == DialpadChooserAdapter.DIALPAD_CHOICE_USE_DTMF_DIALPAD) {
// Fire off an intent to go back to the in-call UI
// with the dialpad visible.
returnToInCallScreen(true);
} else if (itemId == DialpadChooserAdapter.DIALPAD_CHOICE_RETURN_TO_CALL) {
// Fire off an intent to go back to the in-call UI
// (with the dialpad hidden).
returnToInCallScreen(false);
} else if (itemId == DialpadChooserAdapter.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);
} else {
LogUtil.w("DialpadFragment.onItemClick", "Unexpected itemId: " + itemId);
}
}
/**
* 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) {
TelecomUtil.showInCallScreen(getActivity(), showDialpad);
// 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, or on hold).
*/
private boolean isPhoneInUse() {
return getContext() != null
&& TelecomUtil.isInManagedCall(getContext())
&& FragmentUtils.getParentUnsafe(this, HostInterface.class).shouldShowDialpadChooser();
}
/** @return true if the phone is a CDMA phone type */
private boolean phoneIsCdma() {
return getTelephonyManager().getPhoneType() == TelephonyManager.PHONE_TYPE_CDMA;
}
@Override
public boolean onMenuItemClick(MenuItem item) {
int resId = item.getItemId();
if (resId == R.id.menu_2s_pause) {
updateDialString(PAUSE);
return true;
} else if (resId == R.id.menu_add_wait) {
updateDialString(WAIT);
return true;
} else if (resId == R.id.menu_call_with_note) {
CallSubjectDialog.start(getActivity(), digits.getText().toString());
hideAndClearDialpad();
return true;
} else {
return false;
}
}
/**
* Updates the dial string (mDigits) after inserting a Pause character (,) or Wait character (;).
*/
private void updateDialString(char newDigit) {
if (newDigit != WAIT && newDigit != PAUSE) {
throw new IllegalArgumentException("Not expected for anything other than PAUSE & WAIT");
}
int selectionStart;
int selectionEnd;
// SpannableStringBuilder editable_text = new SpannableStringBuilder(mDigits.getText());
int anchor = this.digits.getSelectionStart();
int point = this.digits.getSelectionEnd();
selectionStart = Math.min(anchor, point);
selectionEnd = Math.max(anchor, point);
if (selectionStart == -1) {
selectionStart = selectionEnd = this.digits.length();
}
Editable digits = this.digits.getText();
if (canAddDigit(digits, selectionStart, selectionEnd, newDigit)) {
digits.replace(selectionStart, selectionEnd, Character.toString(newDigit));
if (selectionStart != selectionEnd) {
// Unselect: back to a regular cursor, just pass the character inserted.
this.digits.setSelection(selectionStart + 1);
}
}
}
/** Update the enabledness of the "Dial" and "Backspace" buttons if applicable. */
private void updateDeleteButtonEnabledState() {
if (getActivity() == null) {
return;
}
final boolean digitsNotEmpty = !isDigitsEmpty();
delete.setEnabled(digitsNotEmpty);
}
/**
* Handle transitions for the menu button depending on the state of the digits edit text.
* Transition out when going from digits to no digits and transition in when the first digit is
* pressed.
*
* @param transitionIn True if transitioning in, False if transitioning out
*/
private void updateMenuOverflowButton(boolean transitionIn) {
overflowMenuButton = dialpadView.getOverflowMenuButton();
if (transitionIn) {
AnimUtils.fadeIn(overflowMenuButton, AnimUtils.DEFAULT_DURATION);
} else {
AnimUtils.fadeOut(
overflowMenuButton,
AnimUtils.DEFAULT_DURATION,
new AnimationCallback() {
@Override
public void onAnimationEnd() {
// AnimUtils will set the visibility to GONE and cause the layout to move around.
overflowMenuButton.setVisibility(View.INVISIBLE);
}
});
}
}
/**
* Check if voicemail is enabled/accessible.
*
* @return true if voicemail is enabled and accessible. Note that this can be false "temporarily"
* after the app boot.
*/
private boolean isVoicemailAvailable() {
try {
PhoneAccountHandle defaultUserSelectedAccount =
TelecomUtil.getDefaultOutgoingPhoneAccount(getActivity(), PhoneAccount.SCHEME_VOICEMAIL);
if (defaultUserSelectedAccount == null) {
// In a single-SIM phone, there is no default outgoing phone account selected by
// the user, so just call TelephonyManager#getVoicemailNumber directly.
return !TextUtils.isEmpty(getTelephonyManager().getVoiceMailNumber());
} else {
return !TextUtils.isEmpty(
TelecomUtil.getVoicemailNumber(getActivity(), defaultUserSelectedAccount));
}
} catch (SecurityException se) {
// Possibly no READ_PHONE_STATE privilege.
LogUtil.w(
"DialpadFragment.isVoicemailAvailable",
"SecurityException is thrown. Maybe privilege isn't sufficient.");
}
return false;
}
/** @return true if the widget with the phone number digits is empty. */
private boolean isDigitsEmpty() {
return digits.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() {
lastNumberDialed = EMPTY_NUMBER;
if (!PermissionsUtil.hasCallLogReadPermissions(getContext())) {
return;
}
FragmentUtils.getParentUnsafe(this, DialpadListener.class)
.getLastOutgoingCall(
number -> {
// TODO: Filter out emergency numbers if the carrier does not want redial for these.
// If the fragment has already been detached since the last time we called
// queryLastOutgoingCall in onResume there is no point doing anything here.
if (getActivity() == null) {
return;
}
lastNumberDialed = number;
updateDeleteButtonEnabledState();
});
}
private Intent newFlashIntent() {
Intent intent = new CallIntentBuilder(EMPTY_NUMBER, CallInitiationType.Type.DIALPAD).build();
intent.putExtra(EXTRA_SEND_EMPTY_FLASH, true);
return intent;
}
@Override
public void onHiddenChanged(boolean hidden) {
super.onHiddenChanged(hidden);
if (getActivity() == null || getView() == null) {
return;
}
if (!hidden && !isDialpadChooserVisible()) {
if (animate) {
dialpadView.animateShow();
}
FragmentUtils.getParentUnsafe(this, DialpadListener.class).onDialpadShown();
digits.requestFocus();
}
}
public boolean getAnimate() {
return animate;
}
public void setAnimate(boolean value) {
animate = value;
}
public void setYFraction(float yFraction) {
((DialpadSlidingRelativeLayout) getView()).setYFraction(yFraction);
}
public int getDialpadHeight() {
if (dialpadView == null) {
return 0;
}
return dialpadView.getHeight();
}
public void process_quote_emergency_unquote(String query) {
if (PseudoEmergencyAnimator.PSEUDO_EMERGENCY_NUMBER.equals(query)) {
if (pseudoEmergencyAnimator == null) {
pseudoEmergencyAnimator =
new PseudoEmergencyAnimator(
new PseudoEmergencyAnimator.ViewProvider() {
@Override
public View getFab() {
return floatingActionButton;
}
@Override
public Context getContext() {
return DialpadFragment.this.getContext();
}
});
}
pseudoEmergencyAnimator.start();
} else {
if (pseudoEmergencyAnimator != null) {
pseudoEmergencyAnimator.end();
}
}
}
/** Animate the dialpad down off the screen. */
public void slideDown(boolean animate, AnimationListener listener) {
Assert.checkArgument(isDialpadSlideUp);
isDialpadSlideUp = false;
int animation;
if (isLandscape) {
animation = isLayoutRtl ? R.anim.dialpad_slide_out_left : R.anim.dialpad_slide_out_right;
} else {
animation = R.anim.dialpad_slide_out_bottom;
}
Animation slideDown = AnimationUtils.loadAnimation(getContext(), animation);
slideDown.setInterpolator(AnimUtils.EASE_OUT);
slideDown.setAnimationListener(listener);
slideDown.setDuration(animate ? dialpadSlideInDuration : 0);
getView().startAnimation(slideDown);
floatingActionButtonController.scaleOut();
}
/** Animate the dialpad up onto the screen. */
public void slideUp(boolean animate) {
Assert.checkArgument(!isDialpadSlideUp);
isDialpadSlideUp = true;
int animation;
if (isLandscape) {
animation = isLayoutRtl ? R.anim.dialpad_slide_in_left : R.anim.dialpad_slide_in_right;
} else {
animation = R.anim.dialpad_slide_in_bottom;
}
Animation slideUp = AnimationUtils.loadAnimation(getContext(), animation);
slideUp.setInterpolator(AnimUtils.EASE_IN);
slideUp.setDuration(animate ? dialpadSlideInDuration : 0);
slideUp.setAnimationListener(
new AnimationListener() {
@Override
public void onAnimationStart(Animation animation) {}
@Override
public void onAnimationEnd(Animation animation) {
floatingActionButtonController.scaleIn();
}
@Override
public void onAnimationRepeat(Animation animation) {}
});
getView().startAnimation(slideUp);
}
public boolean isDialpadSlideUp() {
return isDialpadSlideUp;
}
/** Returns the text in the dialpad */
public String getQuery() {
return digits.getText().toString();
}
public interface OnDialpadQueryChangedListener {
void onDialpadQueryChanged(String query);
}
public interface HostInterface {
/**
* Notifies the parent activity that the space above the dialpad has been tapped with no query
* in the dialpad present. In most situations this will cause the dialpad to be dismissed,
* unless there happens to be content showing.
*/
boolean onDialpadSpacerTouchWithEmptyQuery();
/** Returns true if this fragment's parent want the dialpad to show the dialpad chooser. */
boolean shouldShowDialpadChooser();
}
/**
* LinearLayout with getter and setter methods for the translationY property using floats, for
* animation purposes.
*/
public static class DialpadSlidingRelativeLayout extends RelativeLayout {
public DialpadSlidingRelativeLayout(Context context) {
super(context);
}
public DialpadSlidingRelativeLayout(Context context, AttributeSet attrs) {
super(context, attrs);
}
public DialpadSlidingRelativeLayout(Context context, AttributeSet attrs, int defStyle) {
super(context, attrs, defStyle);
}
@UsedByReflection(value = "dialpad_fragment.xml")
public float getYFraction() {
final int height = getHeight();
if (height == 0) {
return 0;
}
return getTranslationY() / height;
}
@UsedByReflection(value = "dialpad_fragment.xml")
public void setYFraction(float yFraction) {
setTranslationY(yFraction * getHeight());
}
}
public static class ErrorDialogFragment extends DialogFragment {
private static final String ARG_TITLE_RES_ID = "argTitleResId";
private static final String ARG_MESSAGE_RES_ID = "argMessageResId";
private int titleResId;
private int messageResId;
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);
titleResId = getArguments().getInt(ARG_TITLE_RES_ID);
messageResId = getArguments().getInt(ARG_MESSAGE_RES_ID);
}
@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
if (titleResId != 0) {
builder.setTitle(titleResId);
}
if (messageResId != 0) {
builder.setMessage(messageResId);
}
builder.setPositiveButton(android.R.string.ok, (dialog, which) -> dismiss());
return builder.create();
}
}
/**
* Simple list adapter, binding to an icon + text label for each item in the "dialpad chooser"
* list.
*/
private static class DialpadChooserAdapter extends BaseAdapter {
// 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 LayoutInflater inflater;
private ChoiceItem[] choiceItems = new ChoiceItem[NUM_ITEMS];
DialpadChooserAdapter(Context context) {
// Cache the LayoutInflate to avoid asking for a new one each time.
inflater = LayoutInflater.from(context);
// Initialize the possible choices.
// TODO: could this be specified entirely in XML?
// - "Use touch tone keypad"
choiceItems[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"
choiceItems[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"
choiceItems[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 choiceItems[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 = inflater.inflate(R.layout.dialpad_chooser_list_item, null);
}
TextView text = convertView.findViewById(R.id.text);
text.setText(choiceItems[position].text);
ImageView icon = convertView.findViewById(R.id.icon);
icon.setImageBitmap(choiceItems[position].icon);
return convertView;
}
// Simple struct for a single "choice" item.
static class ChoiceItem {
String text;
Bitmap icon;
int id;
ChoiceItem(String s, Bitmap b, int i) {
text = s;
icon = b;
id = i;
}
}
}
private class CallStateReceiver extends BroadcastReceiver {
/**
* Receive call 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 onReceive(Context context, Intent intent) {
String state = intent.getStringExtra(TelephonyManager.EXTRA_STATE);
if ((TextUtils.equals(state, TelephonyManager.EXTRA_STATE_IDLE)
|| TextUtils.equals(state, TelephonyManager.EXTRA_STATE_OFFHOOK))
&& isDialpadChooserVisible()) {
// 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...)
LogUtil.i("CallStateReceiver.onReceive", "hiding dialpad chooser, state: %s", state);
showDialpadChooser(false);
}
}
}
/** Listener for dialpad's parent. */
public interface DialpadListener {
void getLastOutgoingCall(LastOutgoingCallCallback callback);
void onDialpadShown();
void onCallPlacedFromDialpad();
}
/** Callback for async lookup of the last number dialed. */
public interface LastOutgoingCallCallback {
void lastOutgoingCall(String number);
}
/**
* A worker that helps formatting the phone number as the user types it in.
*
* <p>Input: the ISO 3166-1 two-letter country code of the country the user is in.
*
* <p>Output: an instance of {@link DialerPhoneNumberFormattingTextWatcher}. Note: It is unusual
* to return a non-data value from a worker. But {@link DialerPhoneNumberFormattingTextWatcher}
* depends on libphonenumber API, which cannot be initialized on the main thread.
*/
private static class InitPhoneNumberFormattingTextWatcherWorker
implements Worker<String, DialerPhoneNumberFormattingTextWatcher> {
@Nullable
@Override
public DialerPhoneNumberFormattingTextWatcher doInBackground(@Nullable String countryCode) {
return new DialerPhoneNumberFormattingTextWatcher(countryCode);
}
}
/**
* An extension of Android telephony's {@link PhoneNumberFormattingTextWatcher}. This watcher
* skips formatting Argentina mobile numbers for domestic calls.
*
* <p>As of Nov. 28, 2017, the as-you-type-formatting provided by libphonenumber's
* AsYouTypeFormatter (which {@link PhoneNumberFormattingTextWatcher} depends on) can't correctly
* format Argentina mobile numbers for domestic calls (a bug). We temporarily disable the
* formatting for such numbers until libphonenumber is fixed (which will come as early as the next
* Android release).
*/
@VisibleForTesting
public static class DialerPhoneNumberFormattingTextWatcher
extends PhoneNumberFormattingTextWatcher {
private static final Pattern AR_DOMESTIC_CALL_MOBILE_NUMBER_PATTERN;
// This static initialization block builds a pattern for domestic calls to Argentina mobile
// numbers:
// (1) Local calls: 15 <local number>
// (2) Long distance calls: <area code> 15 <local number>
// See https://en.wikipedia.org/wiki/Telephone_numbers_in_Argentina for detailed explanations.
static {
String regex =
"0?("
+ " ("
+ " 11|"
+ " 2("
+ " 2("
+ " 02?|"
+ " [13]|"
+ " 2[13-79]|"
+ " 4[1-6]|"
+ " 5[2457]|"
+ " 6[124-8]|"
+ " 7[1-4]|"
+ " 8[13-6]|"
+ " 9[1267]"
+ " )|"
+ " 3("
+ " 02?|"
+ " 1[467]|"
+ " 2[03-6]|"
+ " 3[13-8]|"
+ " [49][2-6]|"
+ " 5[2-8]|"
+ " [67]"
+ " )|"
+ " 4("
+ " 7[3-578]|"
+ " 9"
+ " )|"
+ " 6("
+ " [0136]|"
+ " 2[24-6]|"
+ " 4[6-8]?|"
+ " 5[15-8]"
+ " )|"
+ " 80|"
+ " 9("
+ " 0[1-3]|"
+ " [19]|"
+ " 2\\d|"
+ " 3[1-6]|"
+ " 4[02568]?|"
+ " 5[2-4]|"
+ " 6[2-46]|"
+ " 72?|"
+ " 8[23]?"
+ " )"
+ " )|"
+ " 3("
+ " 3("
+ " 2[79]|"
+ " 6|"
+ " 8[2578]"
+ " )|"
+ " 4("
+ " 0[0-24-9]|"
+ " [12]|"
+ " 3[5-8]?|"
+ " 4[24-7]|"
+ " 5[4-68]?|"
+ " 6[02-9]|"
+ " 7[126]|"
+ " 8[2379]?|"
+ " 9[1-36-8]"
+ " )|"
+ " 5("
+ " 1|"
+ " 2[1245]|"
+ " 3[237]?|"
+ " 4[1-46-9]|"
+ " 6[2-4]|"
+ " 7[1-6]|"
+ " 8[2-5]?"
+ " )|"
+ " 6[24]|"
+ " 7("
+ " [069]|"
+ " 1[1568]|"
+ " 2[15]|"
+ " 3[145]|"
+ " 4[13]|"
+ " 5[14-8]|"
+ " 7[2-57]|"
+ " 8[126]"
+ " )|"
+ " 8("
+ " [01]|"
+ " 2[15-7]|"
+ " 3[2578]?|"
+ " 4[13-6]|"
+ " 5[4-8]?|"
+ " 6[1-357-9]|"
+ " 7[36-8]?|"
+ " 8[5-8]?|"
+ " 9[124]"
+ " )"
+ " )"
+ " )?15"
+ ").*";
AR_DOMESTIC_CALL_MOBILE_NUMBER_PATTERN = Pattern.compile(regex.replaceAll("\\s+", ""));
}
private final String countryCode;
DialerPhoneNumberFormattingTextWatcher(String countryCode) {
super(countryCode);
this.countryCode = countryCode;
}
@Override
public synchronized void afterTextChanged(Editable s) {
// When the country code is NOT "AR", Android telephony's PhoneNumberFormattingTextWatcher can
// correctly handle the input so we will let it do its job.
if (!Ascii.toUpperCase(countryCode).equals("AR")) {
super.afterTextChanged(s);
return;
}
// When the country code is "AR", PhoneNumberFormattingTextWatcher can also format the input
// correctly if the number is NOT for a domestic call to a mobile phone.
String rawNumber = getRawNumber(s);
Matcher matcher = AR_DOMESTIC_CALL_MOBILE_NUMBER_PATTERN.matcher(rawNumber);
if (!matcher.matches()) {
super.afterTextChanged(s);
return;
}
// As modifying the input will trigger another call to afterTextChanged(Editable), we must
// check whether the input's format has already been removed and return if it has
// been to avoid infinite recursion.
if (rawNumber.contentEquals(s)) {
return;
}
// If we reach this point, the country code must be "AR" and variable "s" represents a number
// for a domestic call to a mobile phone. "s" is incorrectly formatted by Android telephony's
// PhoneNumberFormattingTextWatcher so we remove its format by replacing it with the raw
// number.
s.replace(0, s.length(), rawNumber);
// Make sure the cursor is at the end of the text.
Selection.setSelection(s, s.length());
PhoneNumberUtils.addTtsSpan(s, 0 /* start */, s.length() /* endExclusive */);
}
private static String getRawNumber(Editable s) {
StringBuilder rawNumberBuilder = new StringBuilder();
for (int i = 0; i < s.length(); i++) {
char c = s.charAt(i);
if (PhoneNumberUtils.isNonSeparator(c)) {
rawNumberBuilder.append(c);
}
}
return rawNumberBuilder.toString();
}
}
}