diff options
Diffstat (limited to 'src/com/android/phone/DTMFTwelveKeyDialer.java')
| -rw-r--r-- | src/com/android/phone/DTMFTwelveKeyDialer.java | 1119 |
1 files changed, 1119 insertions, 0 deletions
diff --git a/src/com/android/phone/DTMFTwelveKeyDialer.java b/src/com/android/phone/DTMFTwelveKeyDialer.java new file mode 100644 index 00000000..4afac55b --- /dev/null +++ b/src/com/android/phone/DTMFTwelveKeyDialer.java @@ -0,0 +1,1119 @@ +/* + * 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); + } + } + +} |