blob: 4afac55b09606b3892beacd840402392110d40b1 [file] [log] [blame]
/*
* Copyright (C) 2008 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.phone;
import android.content.Context;
import android.media.AudioManager;
import android.media.ToneGenerator;
import android.os.Handler;
import android.os.Message;
import android.provider.Settings;
import android.telephony.PhoneNumberUtils;
import android.text.Editable;
import android.text.SpannableString;
import android.text.method.DialerKeyListener;
import android.text.style.RelativeSizeSpan;
import android.util.Log;
import android.view.KeyEvent;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewConfiguration;
import android.view.View.OnHoverListener;
import android.view.accessibility.AccessibilityManager;
import android.view.ViewStub;
import android.widget.EditText;
import com.android.internal.telephony.CallManager;
import com.android.internal.telephony.Phone;
import com.android.internal.telephony.PhoneConstants;
import com.android.internal.telephony.TelephonyCapabilities;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Queue;
/**
* Dialer class that encapsulates the DTMF twelve key behaviour.
* This model backs up the UI behaviour in DTMFTwelveKeyDialerView.java.
*/
public class DTMFTwelveKeyDialer implements View.OnTouchListener, View.OnKeyListener,
View.OnHoverListener, View.OnClickListener {
private static final String LOG_TAG = "DTMFTwelveKeyDialer";
private static final boolean DBG = (PhoneGlobals.DBG_LEVEL >= 2);
// events
private static final int PHONE_DISCONNECT = 100;
private static final int DTMF_SEND_CNF = 101;
private static final int DTMF_STOP = 102;
/** Accessibility manager instance used to check touch exploration state. */
private final AccessibilityManager mAccessibilityManager;
private CallManager mCM;
private ToneGenerator mToneGenerator;
private final Object mToneGeneratorLock = new Object();
// indicate if we want to enable the local tone playback.
private boolean mLocalToneEnabled;
// indicates that we are using automatically shortened DTMF tones
boolean mShortTone;
// indicate if the confirmation from TelephonyFW is pending.
private boolean mDTMFBurstCnfPending = false;
// Queue to queue the short dtmf characters.
private Queue<Character> mDTMFQueue = new LinkedList<Character>();
// Short Dtmf tone duration
private static final int DTMF_DURATION_MS = 120;
/** Hash Map to map a character to a tone*/
private static final HashMap<Character, Integer> mToneMap =
new HashMap<Character, Integer>();
/** Hash Map to map a view id to a character*/
private static final HashMap<Integer, Character> mDisplayMap =
new HashMap<Integer, Character>();
/** Set up the static maps*/
static {
// Map the key characters to tones
mToneMap.put('1', ToneGenerator.TONE_DTMF_1);
mToneMap.put('2', ToneGenerator.TONE_DTMF_2);
mToneMap.put('3', ToneGenerator.TONE_DTMF_3);
mToneMap.put('4', ToneGenerator.TONE_DTMF_4);
mToneMap.put('5', ToneGenerator.TONE_DTMF_5);
mToneMap.put('6', ToneGenerator.TONE_DTMF_6);
mToneMap.put('7', ToneGenerator.TONE_DTMF_7);
mToneMap.put('8', ToneGenerator.TONE_DTMF_8);
mToneMap.put('9', ToneGenerator.TONE_DTMF_9);
mToneMap.put('0', ToneGenerator.TONE_DTMF_0);
mToneMap.put('#', ToneGenerator.TONE_DTMF_P);
mToneMap.put('*', ToneGenerator.TONE_DTMF_S);
// Map the buttons to the display characters
mDisplayMap.put(R.id.one, '1');
mDisplayMap.put(R.id.two, '2');
mDisplayMap.put(R.id.three, '3');
mDisplayMap.put(R.id.four, '4');
mDisplayMap.put(R.id.five, '5');
mDisplayMap.put(R.id.six, '6');
mDisplayMap.put(R.id.seven, '7');
mDisplayMap.put(R.id.eight, '8');
mDisplayMap.put(R.id.nine, '9');
mDisplayMap.put(R.id.zero, '0');
mDisplayMap.put(R.id.pound, '#');
mDisplayMap.put(R.id.star, '*');
}
/** EditText field used to display the DTMF digits sent so far.
Note this is null in some modes (like during the CDMA OTA call,
where there's no onscreen "digits" display.) */
private EditText mDialpadDigits;
// InCallScreen reference.
private InCallScreen mInCallScreen;
/**
* The DTMFTwelveKeyDialerView we use to display the dialpad.
*
* Only one of mDialerView or mDialerStub will have a legitimate object; the other one will be
* null at that moment. Either of following scenarios will occur:
*
* - If the constructor with {@link DTMFTwelveKeyDialerView} is called, mDialerView will
* obtain that object, and mDialerStub will be null. mDialerStub won't be used in this case.
*
* - If the constructor with {@link ViewStub} is called, mDialerView will be null at that
* moment, and mDialerStub will obtain the ViewStub object.
* When the dialer is required by the user (i.e. until {@link #openDialer(boolean)} being
* called), mDialerStub will inflate the dialer, and make mDialerStub itself null.
* mDialerStub won't be used afterward.
*/
private DTMFTwelveKeyDialerView mDialerView;
/**
* {@link ViewStub} holding {@link DTMFTwelveKeyDialerView}. See the comments for mDialerView.
*/
private ViewStub mDialerStub;
// KeyListener used with the "dialpad digits" EditText widget.
private DTMFKeyListener mDialerKeyListener;
/**
* Our own key listener, specialized for dealing with DTMF codes.
* 1. Ignore the backspace since it is irrelevant.
* 2. Allow ONLY valid DTMF characters to generate a tone and be
* sent as a DTMF code.
* 3. All other remaining characters are handled by the superclass.
*
* This code is purely here to handle events from the hardware keyboard
* while the DTMF dialpad is up.
*/
private class DTMFKeyListener extends DialerKeyListener {
private DTMFKeyListener() {
super();
}
/**
* Overriden to return correct DTMF-dialable characters.
*/
@Override
protected char[] getAcceptedChars(){
return DTMF_CHARACTERS;
}
/** special key listener ignores backspace. */
@Override
public boolean backspace(View view, Editable content, int keyCode,
KeyEvent event) {
return false;
}
/**
* Return true if the keyCode is an accepted modifier key for the
* dialer (ALT or SHIFT).
*/
private boolean isAcceptableModifierKey(int keyCode) {
switch (keyCode) {
case KeyEvent.KEYCODE_ALT_LEFT:
case KeyEvent.KEYCODE_ALT_RIGHT:
case KeyEvent.KEYCODE_SHIFT_LEFT:
case KeyEvent.KEYCODE_SHIFT_RIGHT:
return true;
default:
return false;
}
}
/**
* Overriden so that with each valid button press, we start sending
* a dtmf code and play a local dtmf tone.
*/
@Override
public boolean onKeyDown(View view, Editable content,
int keyCode, KeyEvent event) {
// if (DBG) log("DTMFKeyListener.onKeyDown, keyCode " + keyCode + ", view " + view);
// find the character
char c = (char) lookup(event, content);
// if not a long press, and parent onKeyDown accepts the input
if (event.getRepeatCount() == 0 && super.onKeyDown(view, content, keyCode, event)) {
boolean keyOK = ok(getAcceptedChars(), c);
// if the character is a valid dtmf code, start playing the tone and send the
// code.
if (keyOK) {
if (DBG) log("DTMFKeyListener reading '" + c + "' from input.");
processDtmf(c);
} else if (DBG) {
log("DTMFKeyListener rejecting '" + c + "' from input.");
}
return true;
}
return false;
}
/**
* Overriden so that with each valid button up, we stop sending
* a dtmf code and the dtmf tone.
*/
@Override
public boolean onKeyUp(View view, Editable content,
int keyCode, KeyEvent event) {
// if (DBG) log("DTMFKeyListener.onKeyUp, keyCode " + keyCode + ", view " + view);
super.onKeyUp(view, content, keyCode, event);
// find the character
char c = (char) lookup(event, content);
boolean keyOK = ok(getAcceptedChars(), c);
if (keyOK) {
if (DBG) log("Stopping the tone for '" + c + "'");
stopTone();
return true;
}
return false;
}
/**
* Handle individual keydown events when we DO NOT have an Editable handy.
*/
public boolean onKeyDown(KeyEvent event) {
char c = lookup(event);
if (DBG) log("DTMFKeyListener.onKeyDown: event '" + c + "'");
// if not a long press, and parent onKeyDown accepts the input
if (event.getRepeatCount() == 0 && c != 0) {
// if the character is a valid dtmf code, start playing the tone and send the
// code.
if (ok(getAcceptedChars(), c)) {
if (DBG) log("DTMFKeyListener reading '" + c + "' from input.");
processDtmf(c);
return true;
} else if (DBG) {
log("DTMFKeyListener rejecting '" + c + "' from input.");
}
}
return false;
}
/**
* Handle individual keyup events.
*
* @param event is the event we are trying to stop. If this is null,
* then we just force-stop the last tone without checking if the event
* is an acceptable dialer event.
*/
public boolean onKeyUp(KeyEvent event) {
if (event == null) {
//the below piece of code sends stopDTMF event unnecessarily even when a null event
//is received, hence commenting it.
/*if (DBG) log("Stopping the last played tone.");
stopTone();*/
return true;
}
char c = lookup(event);
if (DBG) log("DTMFKeyListener.onKeyUp: event '" + c + "'");
// TODO: stopTone does not take in character input, we may want to
// consider checking for this ourselves.
if (ok(getAcceptedChars(), c)) {
if (DBG) log("Stopping the tone for '" + c + "'");
stopTone();
return true;
}
return false;
}
/**
* Find the Dialer Key mapped to this event.
*
* @return The char value of the input event, otherwise
* 0 if no matching character was found.
*/
private char lookup(KeyEvent event) {
// This code is similar to {@link DialerKeyListener#lookup(KeyEvent, Spannable) lookup}
int meta = event.getMetaState();
int number = event.getNumber();
if (!((meta & (KeyEvent.META_ALT_ON | KeyEvent.META_SHIFT_ON)) == 0) || (number == 0)) {
int match = event.getMatch(getAcceptedChars(), meta);
number = (match != 0) ? match : number;
}
return (char) number;
}
/**
* Check to see if the keyEvent is dialable.
*/
boolean isKeyEventAcceptable (KeyEvent event) {
return (ok(getAcceptedChars(), lookup(event)));
}
/**
* Overrides the characters used in {@link DialerKeyListener#CHARACTERS}
* These are the valid dtmf characters.
*/
public final char[] DTMF_CHARACTERS = new char[] {
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '#', '*'
};
}
/**
* Our own handler to take care of the messages from the phone state changes
*/
private final Handler mHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
// disconnect action
// make sure to close the dialer on ALL disconnect actions.
case PHONE_DISCONNECT:
if (DBG) log("disconnect message recieved, shutting down.");
// unregister since we are closing.
mCM.unregisterForDisconnect(this);
closeDialer(false);
break;
case DTMF_SEND_CNF:
if (DBG) log("dtmf confirmation received from FW.");
// handle burst dtmf confirmation
handleBurstDtmfConfirmation();
break;
case DTMF_STOP:
if (DBG) log("dtmf stop received");
stopTone();
break;
}
}
};
/**
* DTMFTwelveKeyDialer constructor with {@link DTMFTwelveKeyDialerView}
*
* @param parent the InCallScreen instance that owns us.
* @param dialerView the DTMFTwelveKeyDialerView we should use to display the dialpad.
*/
public DTMFTwelveKeyDialer(InCallScreen parent,
DTMFTwelveKeyDialerView dialerView) {
this(parent);
// The passed-in DTMFTwelveKeyDialerView *should* always be
// non-null, now that the in-call UI uses only portrait mode.
if (dialerView == null) {
Log.e(LOG_TAG, "DTMFTwelveKeyDialer: null dialerView!", new IllegalStateException());
// ...continue as best we can, although things will
// be pretty broken without the mDialerView UI elements!
}
mDialerView = dialerView;
if (DBG) log("- Got passed-in mDialerView: " + mDialerView);
if (mDialerView != null) {
setupDialerView();
}
}
/**
* DTMFTwelveKeyDialer constructor with {@link ViewStub}.
*
* When the dialer is required for the first time (e.g. when {@link #openDialer(boolean)} is
* called), the object will inflate the ViewStub by itself, assuming the ViewStub will return
* {@link DTMFTwelveKeyDialerView} on {@link ViewStub#inflate()}.
*
* @param parent the InCallScreen instance that owns us.
* @param dialerStub ViewStub which will return {@link DTMFTwelveKeyDialerView} on
* {@link ViewStub#inflate()}.
*/
public DTMFTwelveKeyDialer(InCallScreen parent, ViewStub dialerStub) {
this(parent);
mDialerStub = dialerStub;
if (DBG) log("- Got passed-in mDialerStub: " + mDialerStub);
// At this moment mDialerView is still null. We delay calling setupDialerView().
}
/**
* Private constructor used for initialization calls common to all public
* constructors.
*
* @param parent the InCallScreen instance that owns us.
*/
private DTMFTwelveKeyDialer(InCallScreen parent) {
if (DBG) log("DTMFTwelveKeyDialer constructor... this = " + this);
mInCallScreen = parent;
mCM = PhoneGlobals.getInstance().mCM;
mAccessibilityManager = (AccessibilityManager) parent.getSystemService(
Context.ACCESSIBILITY_SERVICE);
}
/**
* Prepare the dialer view and relevant variables.
*/
private void setupDialerView() {
if (DBG) log("setupDialerView()");
mDialerView.setDialer(this);
// In the normal in-call DTMF dialpad, mDialpadDigits is an
// EditText used to display the digits the user has typed so
// far. But some other modes (like the OTA call) have no
// "digits" display at all, in which case mDialpadDigits will
// be null.
mDialpadDigits = (EditText) mDialerView.findViewById(R.id.dtmfDialerField);
if (mDialpadDigits != null) {
mDialerKeyListener = new DTMFKeyListener();
mDialpadDigits.setKeyListener(mDialerKeyListener);
// remove the long-press context menus that support
// the edit (copy / paste / select) functions.
mDialpadDigits.setLongClickable(false);
}
// Hook up touch / key listeners for the buttons in the onscreen
// keypad.
setupKeypad(mDialerView);
}
/**
* Null out our reference to the InCallScreen activity.
* This indicates that the InCallScreen activity has been destroyed.
* At the same time, get rid of listeners since we're not going to
* be valid anymore.
*/
/* package */ void clearInCallScreenReference() {
if (DBG) log("clearInCallScreenReference()...");
mInCallScreen = null;
mDialerKeyListener = null;
mHandler.removeMessages(DTMF_SEND_CNF);
synchronized (mDTMFQueue) {
mDTMFBurstCnfPending = false;
mDTMFQueue.clear();
}
closeDialer(false);
}
/**
* Dialer code that runs when the dialer is brought up.
* This includes layout changes, etc, and just prepares the dialer model for use.
*/
private void onDialerOpen(boolean animate) {
if (DBG) log("onDialerOpen()...");
// Any time the dialer is open, listen for "disconnect" events (so
// we can close ourself.)
mCM.registerForDisconnect(mHandler, PHONE_DISCONNECT, null);
// On some devices the screen timeout is set to a special value
// while the dialpad is up.
PhoneGlobals.getInstance().updateWakeState();
// Give the InCallScreen a chance to do any necessary UI updates.
if (mInCallScreen != null) {
mInCallScreen.onDialerOpen(animate);
} else {
Log.e(LOG_TAG, "InCallScreen object was null during onDialerOpen()");
}
}
/**
* Allocates some resources we keep around during a "dialer session".
*
* (Currently, a "dialer session" just means any situation where we
* might need to play local DTMF tones, which means that we need to
* keep a ToneGenerator instance around. A ToneGenerator instance
* keeps an AudioTrack resource busy in AudioFlinger, so we don't want
* to keep it around forever.)
*
* Call {@link stopDialerSession} to release the dialer session
* resources.
*/
public void startDialerSession() {
if (DBG) log("startDialerSession()... this = " + this);
// see if we need to play local tones.
if (PhoneGlobals.getInstance().getResources().getBoolean(R.bool.allow_local_dtmf_tones)) {
mLocalToneEnabled = Settings.System.getInt(mInCallScreen.getContentResolver(),
Settings.System.DTMF_TONE_WHEN_DIALING, 1) == 1;
} else {
mLocalToneEnabled = false;
}
if (DBG) log("- startDialerSession: mLocalToneEnabled = " + mLocalToneEnabled);
// create the tone generator
// 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.
if (mLocalToneEnabled) {
synchronized (mToneGeneratorLock) {
if (mToneGenerator == null) {
try {
mToneGenerator = new ToneGenerator(AudioManager.STREAM_DTMF, 80);
} catch (RuntimeException e) {
if (DBG) log("Exception caught while creating local tone generator: " + e);
mToneGenerator = null;
}
}
}
}
}
/**
* Dialer code that runs when the dialer is closed.
* This releases resources acquired when we start the dialer.
*/
private void onDialerClose(boolean animate) {
if (DBG) log("onDialerClose()...");
// reset back to a short delay for the poke lock.
PhoneGlobals app = PhoneGlobals.getInstance();
app.updateWakeState();
mCM.unregisterForDisconnect(mHandler);
// Give the InCallScreen a chance to do any necessary UI updates.
if (mInCallScreen != null) {
mInCallScreen.onDialerClose(animate);
} else {
Log.e(LOG_TAG, "InCallScreen object was null during onDialerClose()");
}
}
/**
* Releases resources we keep around during a "dialer session"
* (see {@link startDialerSession}).
*
* It's safe to call this even without a corresponding
* startDialerSession call.
*/
public void stopDialerSession() {
// release the tone generator.
synchronized (mToneGeneratorLock) {
if (mToneGenerator != null) {
mToneGenerator.release();
mToneGenerator = null;
}
}
}
/**
* Called externally (from InCallScreen) to play a DTMF Tone.
*/
public boolean onDialerKeyDown(KeyEvent event) {
if (DBG) log("Notifying dtmf key down.");
if (mDialerKeyListener != null) {
return mDialerKeyListener.onKeyDown(event);
} else {
return false;
}
}
/**
* Called externally (from InCallScreen) to cancel the last DTMF Tone played.
*/
public boolean onDialerKeyUp(KeyEvent event) {
if (DBG) log("Notifying dtmf key up.");
if (mDialerKeyListener != null) {
return mDialerKeyListener.onKeyUp(event);
} else {
return false;
}
}
/**
* setup the keys on the dialer activity, using the keymaps.
*/
private void setupKeypad(DTMFTwelveKeyDialerView dialerView) {
// for each view id listed in the displaymap
View button;
for (int viewId : mDisplayMap.keySet()) {
// locate the view
button = dialerView.findViewById(viewId);
// Setup the listeners for the buttons
button.setOnTouchListener(this);
button.setClickable(true);
button.setOnKeyListener(this);
button.setOnHoverListener(this);
button.setOnClickListener(this);
}
}
/**
* catch the back and call buttons to return to the in call activity.
*/
public boolean onKeyDown(int keyCode, KeyEvent event) {
// if (DBG) log("onKeyDown: keyCode " + keyCode);
switch (keyCode) {
// finish for these events
case KeyEvent.KEYCODE_BACK:
case KeyEvent.KEYCODE_CALL:
if (DBG) log("exit requested");
closeDialer(true); // do the "closing" animation
return true;
}
return mInCallScreen.onKeyDown(keyCode, event);
}
/**
* catch the back and call buttons to return to the in call activity.
*/
public boolean onKeyUp(int keyCode, KeyEvent event) {
// if (DBG) log("onKeyUp: keyCode " + keyCode);
return mInCallScreen.onKeyUp(keyCode, event);
}
/**
* Implemented for {@link android.view.View.OnHoverListener}. Handles touch
* events for accessibility when touch exploration is enabled.
*/
@Override
public boolean onHover(View v, MotionEvent event) {
// When touch exploration is turned on, lifting a finger while inside
// the button's hover target bounds should perform a click action.
if (mAccessibilityManager.isEnabled()
&& mAccessibilityManager.isTouchExplorationEnabled()) {
final int left = v.getPaddingLeft();
final int right = (v.getWidth() - v.getPaddingRight());
final int top = v.getPaddingTop();
final int bottom = (v.getHeight() - v.getPaddingBottom());
switch (event.getActionMasked()) {
case MotionEvent.ACTION_HOVER_ENTER:
// Lift-to-type temporarily disables double-tap activation.
v.setClickable(false);
break;
case MotionEvent.ACTION_HOVER_EXIT:
final int x = (int) event.getX();
final int y = (int) event.getY();
if ((x > left) && (x < right) && (y > top) && (y < bottom)) {
v.performClick();
}
v.setClickable(true);
break;
}
}
return false;
}
@Override
public void onClick(View v) {
// When accessibility is on, simulate press and release to preserve the
// semantic meaning of performClick(). Required for Braille support.
if (mAccessibilityManager.isEnabled()) {
final int id = v.getId();
// Checking the press state prevents double activation.
if (!v.isPressed() && mDisplayMap.containsKey(id)) {
processDtmf(mDisplayMap.get(id), true /* timedShortTone */);
}
}
}
/**
* Implemented for the TouchListener, process the touch events.
*/
@Override
public boolean onTouch(View v, MotionEvent event) {
int viewId = v.getId();
// if the button is recognized
if (mDisplayMap.containsKey(viewId)) {
switch (event.getAction()) {
case MotionEvent.ACTION_DOWN:
// Append the character mapped to this button, to the display.
// start the tone
processDtmf(mDisplayMap.get(viewId));
break;
case MotionEvent.ACTION_UP:
case MotionEvent.ACTION_CANCEL:
// stop the tone on ANY other event, except for MOVE.
stopTone();
break;
}
// do not return true [handled] here, since we want the
// press / click animation to be handled by the framework.
}
return false;
}
/**
* Implements View.OnKeyListener for the DTMF buttons. Enables dialing with trackball/dpad.
*/
@Override
public boolean onKey(View v, int keyCode, KeyEvent event) {
// if (DBG) log("onKey: keyCode " + keyCode + ", view " + v);
if (keyCode == KeyEvent.KEYCODE_DPAD_CENTER) {
int viewId = v.getId();
if (mDisplayMap.containsKey(viewId)) {
switch (event.getAction()) {
case KeyEvent.ACTION_DOWN:
if (event.getRepeatCount() == 0) {
processDtmf(mDisplayMap.get(viewId));
}
break;
case KeyEvent.ACTION_UP:
stopTone();
break;
}
// do not return true [handled] here, since we want the
// press / click animation to be handled by the framework.
}
}
return false;
}
/**
* Returns true if the dialer is in "open" state, meaning it is already visible *and* it
* isn't fading out. Note that during fade-out animation the View will return VISIBLE but
* will become GONE soon later, so you would want to use this method instead of
* {@link View#getVisibility()}.
*
* Fade-in animation, on the other hand, will set the View's visibility VISIBLE soon after
* the request, so we don't need to take care much of it. In other words,
* {@link #openDialer(boolean)} soon makes the visibility VISIBLE and thus this method will
* return true just after the method call.
*
* Note: during the very early stage of "open" state, users may not see the dialpad yet because
* of its fading-in animation, while they will see it shortly anyway. Similarly, during the
* early stage of "closed" state (opposite of "open" state), users may still see the dialpad
* due to fading-out animation, but it will vanish shortly and thus we can treat it as "closed",
* or "not open". To make the transition clearer, we call the state "open", not "shown" nor
* "visible".
*/
public boolean isOpened() {
// Return whether or not the dialer view is visible.
// (Note that if we're in the middle of a fade-out animation, that
// also counts as "not visible" even though mDialerView itself is
// technically still VISIBLE.)
return (mDialerView != null
&&(mDialerView.getVisibility() == View.VISIBLE)
&& !AnimationUtils.Fade.isFadingOut(mDialerView));
}
/**
* Forces the dialer into the "open" state.
* Does nothing if the dialer is already open.
*
* The "open" state includes the state the dialer is fading in.
* {@link InCallScreen#onDialerOpen(boolean)} will change visibility state and do
* actual animation.
*
* @param animate if true, open the dialer with an animation.
*
* @see #isOpened
*/
public void openDialer(boolean animate) {
if (DBG) log("openDialer()...");
if (mDialerView == null && mDialerStub != null) {
if (DBG) log("Dialer isn't ready. Inflate it from ViewStub.");
mDialerView = (DTMFTwelveKeyDialerView) mDialerStub.inflate();
setupDialerView();
mDialerStub = null;
}
if (!isOpened()) {
// Make the dialer view visible.
if (animate) {
AnimationUtils.Fade.show(mDialerView);
} else {
mDialerView.setVisibility(View.VISIBLE);
}
onDialerOpen(animate);
}
}
/**
* Forces the dialer into the "closed" state.
* Does nothing if the dialer is already closed.
*
* {@link InCallScreen#onDialerOpen(boolean)} will change visibility state and do
* actual animation.
*
* @param animate if true, close the dialer with an animation.
*
* @see #isOpened
*/
public void closeDialer(boolean animate) {
if (DBG) log("closeDialer()...");
if (isOpened()) {
// Hide the dialer view.
if (animate) {
AnimationUtils.Fade.hide(mDialerView, View.GONE);
} else {
mDialerView.setVisibility(View.GONE);
}
onDialerClose(animate);
}
}
/**
* Processes the specified digit as a DTMF key, by playing the
* appropriate DTMF tone, and appending the digit to the EditText
* field that displays the DTMF digits sent so far.
*
* @see #processDtmf(char, boolean)
*/
private final void processDtmf(char c) {
processDtmf(c, false);
}
/**
* Processes the specified digit as a DTMF key, by playing the appropriate
* DTMF tone (or short tone if requested), and appending the digit to the
* EditText field that displays the DTMF digits sent so far.
*/
private final void processDtmf(char c, boolean timedShortTone) {
// if it is a valid key, then update the display and send the dtmf tone.
if (PhoneNumberUtils.is12Key(c)) {
if (DBG) log("updating display and sending dtmf tone for '" + c + "'");
// Append this key to the "digits" widget.
if (mDialpadDigits != null) {
// TODO: maybe *don't* manually append this digit if
// mDialpadDigits is focused and this key came from the HW
// keyboard, since in that case the EditText field will
// get the key event directly and automatically appends
// whetever the user types.
// (Or, a cleaner fix would be to just make mDialpadDigits
// *not* handle HW key presses. That seems to be more
// complicated than just setting focusable="false" on it,
// though.)
mDialpadDigits.getText().append(c);
}
// Play the tone if it exists.
if (mToneMap.containsKey(c)) {
// begin tone playback.
startTone(c, timedShortTone);
}
} else if (DBG) {
log("ignoring dtmf request for '" + c + "'");
}
// Any DTMF keypress counts as explicit "user activity".
PhoneGlobals.getInstance().pokeUserActivity();
}
/**
* Clears out the display of "DTMF digits typed so far" that's kept in
* mDialpadDigits.
*
* The InCallScreen is responsible for calling this method any time a
* new call becomes active (or, more simply, any time a call ends).
* This is how we make sure that the "history" of DTMF digits you type
* doesn't persist from one call to the next.
*
* TODO: it might be more elegent if the dialpad itself could remember
* the call that we're associated with, and clear the digits if the
* "current call" has changed since last time. (This would require
* some unique identifier that's different for each call. We can't
* just use the foreground Call object, since that's a singleton that
* lasts the whole life of the phone process. Instead, maybe look at
* the Connection object that comes back from getEarliestConnection()?
* Or getEarliestConnectTime()?)
*
* Or to be even fancier, we could keep a mapping of *multiple*
* "active calls" to DTMF strings. That way you could have two lines
* in use and swap calls multiple times, and we'd still remember the
* digits for each call. (But that's such an obscure use case that
* it's probably not worth the extra complexity.)
*/
public void clearDigits() {
if (DBG) log("clearDigits()...");
if (mDialpadDigits != null) {
mDialpadDigits.setText("");
}
setDialpadContext("");
}
/**
* Set the context text (hint) to show in the dialpad Digits EditText.
*
* This is currently only used for displaying a value for "Voice Mail"
* calls since they default to the dialpad and we want to give users better
* context when they dial voicemail.
*
* TODO: Is there value in extending this functionality for all contacts
* and not just Voice Mail calls?
* TODO: This should include setting the digits as well as the context
* once we start saving the digits properly...and properly in this case
* ideally means moving some of processDtmf() out of this class.
*/
public void setDialpadContext(String contextValue) {
if (mDialpadDigits != null) {
if (contextValue == null) {
contextValue = "";
}
final SpannableString hint = new SpannableString(contextValue);
hint.setSpan(new RelativeSizeSpan(0.8f), 0, hint.length(), 0);
mDialpadDigits.setHint(hint);
}
}
/**
* Plays the local tone based the phone type.
*/
public void startTone(char c, boolean timedShortTone) {
// Only play the tone if it exists.
if (!mToneMap.containsKey(c)) {
return;
}
if (!mInCallScreen.okToDialDTMFTones()) {
return;
}
// Read the settings as it may be changed by the user during the call
Phone phone = mCM.getFgPhone();
mShortTone = useShortDtmfTones(phone, phone.getContext());
// Before we go ahead and start a tone, we need to make sure that any pending
// stop-tone message is processed.
if (mHandler.hasMessages(DTMF_STOP)) {
mHandler.removeMessages(DTMF_STOP);
stopTone();
}
if (DBG) log("startDtmfTone()...");
// For Short DTMF we need to play the local tone for fixed duration
if (mShortTone) {
sendShortDtmfToNetwork(c);
} else {
// Pass as a char to be sent to network
if (DBG) log("send long dtmf for " + c);
mCM.startDtmf(c);
// If it is a timed tone, queue up the stop command in DTMF_DURATION_MS.
if (timedShortTone) {
mHandler.sendMessageDelayed(mHandler.obtainMessage(DTMF_STOP), DTMF_DURATION_MS);
}
}
startLocalToneIfNeeded(c);
}
/**
* Plays the local tone based the phone type, optionally forcing a short
* tone.
*/
public void startLocalToneIfNeeded(char c) {
// if local tone playback is enabled, start it.
// Only play the tone if it exists.
if (!mToneMap.containsKey(c)) {
return;
}
if (mLocalToneEnabled) {
synchronized (mToneGeneratorLock) {
if (mToneGenerator == null) {
if (DBG) log("startDtmfTone: mToneGenerator == null, tone: " + c);
} else {
if (DBG) log("starting local tone " + c);
int toneDuration = -1;
if (mShortTone) {
toneDuration = DTMF_DURATION_MS;
}
mToneGenerator.startTone(mToneMap.get(c), toneDuration);
}
}
}
}
/**
* Check to see if the keyEvent is dialable.
*/
boolean isKeyEventAcceptable (KeyEvent event) {
return (mDialerKeyListener != null && mDialerKeyListener.isKeyEventAcceptable(event));
}
/**
* static logging method
*/
private static void log(String msg) {
Log.d(LOG_TAG, msg);
}
/**
* Stops the local tone based on the phone type.
*/
public void stopTone() {
// We do not rely on InCallScreen#okToDialDTMFTones() here since it is ok to stop tones
// without starting them.
if (!mShortTone) {
if (DBG) log("stopping remote tone.");
mCM.stopDtmf();
stopLocalToneIfNeeded();
}
}
/**
* Stops the local tone based on the phone type.
*/
public void stopLocalToneIfNeeded() {
if (!mShortTone) {
// if local tone playback is enabled, stop it.
if (DBG) log("trying to stop local tone...");
if (mLocalToneEnabled) {
synchronized (mToneGeneratorLock) {
if (mToneGenerator == null) {
if (DBG) log("stopLocalTone: mToneGenerator == null");
} else {
if (DBG) log("stopping local tone.");
mToneGenerator.stopTone();
}
}
}
}
}
/**
* Sends the dtmf character over the network for short DTMF settings
* When the characters are entered in quick succession,
* the characters are queued before sending over the network.
*/
private void sendShortDtmfToNetwork(char dtmfDigit) {
synchronized (mDTMFQueue) {
if (mDTMFBurstCnfPending == true) {
// Insert the dtmf char to the queue
mDTMFQueue.add(new Character(dtmfDigit));
} else {
String dtmfStr = Character.toString(dtmfDigit);
mCM.sendBurstDtmf(dtmfStr, 0, 0, mHandler.obtainMessage(DTMF_SEND_CNF));
// Set flag to indicate wait for Telephony confirmation.
mDTMFBurstCnfPending = true;
}
}
}
/**
* Handles Burst Dtmf Confirmation from the Framework.
*/
void handleBurstDtmfConfirmation() {
Character dtmfChar = null;
synchronized (mDTMFQueue) {
mDTMFBurstCnfPending = false;
if (!mDTMFQueue.isEmpty()) {
dtmfChar = mDTMFQueue.remove();
Log.i(LOG_TAG, "The dtmf character removed from queue" + dtmfChar);
}
}
if (dtmfChar != null) {
sendShortDtmfToNetwork(dtmfChar);
}
}
/**
* On GSM devices, we never use short tones.
* On CDMA devices, it depends upon the settings.
*/
private static boolean useShortDtmfTones(Phone phone, Context context) {
int phoneType = phone.getPhoneType();
if (phoneType == PhoneConstants.PHONE_TYPE_GSM) {
return false;
} else if (phoneType == PhoneConstants.PHONE_TYPE_CDMA) {
int toneType = android.provider.Settings.System.getInt(
context.getContentResolver(),
Settings.System.DTMF_TONE_TYPE_WHEN_DIALING,
Constants.DTMF_TONE_TYPE_NORMAL);
if (toneType == Constants.DTMF_TONE_TYPE_NORMAL) {
return true;
} else {
return false;
}
} else if (phoneType == PhoneConstants.PHONE_TYPE_SIP) {
return false;
} else {
throw new IllegalStateException("Unexpected phone type: " + phoneType);
}
}
}