/* * Copyright (C) 2006 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.app.AlertDialog; import android.app.Dialog; import android.app.ProgressDialog; import android.bluetooth.IBluetoothHeadsetPhone; import android.content.ActivityNotFoundException; import android.content.ComponentName; import android.content.Context; import android.content.DialogInterface; import android.content.Intent; import android.content.res.Configuration; import android.media.AudioManager; import android.net.Uri; import android.os.Handler; import android.os.Message; import android.os.PersistableBundle; import android.os.RemoteException; import android.os.SystemProperties; import android.telecom.PhoneAccount; import android.telecom.PhoneAccountHandle; import android.telecom.VideoProfile; import android.telephony.CarrierConfigManager; import android.telephony.PhoneNumberUtils; import android.telephony.SubscriptionManager; import android.text.TextUtils; import android.util.Log; import android.view.ContextThemeWrapper; import android.view.KeyEvent; import android.view.LayoutInflater; import android.view.View; import android.view.WindowManager; import android.widget.EditText; import android.widget.Toast; import com.android.internal.telephony.Call; import com.android.internal.telephony.CallManager; import com.android.internal.telephony.CallStateException; import com.android.internal.telephony.CallerInfo; import com.android.internal.telephony.CallerInfoAsyncQuery; import com.android.internal.telephony.Connection; import com.android.internal.telephony.IccCard; import com.android.internal.telephony.MmiCode; import com.android.internal.telephony.Phone; import com.android.internal.telephony.PhoneConstants; import com.android.internal.telephony.PhoneFactory; import com.android.internal.telephony.TelephonyCapabilities; import com.android.internal.telephony.TelephonyProperties; import com.android.internal.telephony.sip.SipPhone; import com.android.phone.CallGatewayManager.RawGatewayInfo; import com.android.services.telephony.TelephonyConnectionService; import java.util.Arrays; import java.util.List; /** * Misc utilities for the Phone app. */ public class PhoneUtils { public static final String EMERGENCY_ACCOUNT_HANDLE_ID = "E"; private static final String LOG_TAG = "PhoneUtils"; private static final boolean DBG = (PhoneGlobals.DBG_LEVEL >= 2); // Do not check in with VDBG = true, since that may write PII to the system log. private static final boolean VDBG = false; /** Control stack trace for Audio Mode settings */ private static final boolean DBG_SETAUDIOMODE_STACK = false; /** Identifier for the "Add Call" intent extra. */ static final String ADD_CALL_MODE_KEY = "add_call_mode"; // Return codes from placeCall() static final int CALL_STATUS_DIALED = 0; // The number was successfully dialed static final int CALL_STATUS_DIALED_MMI = 1; // The specified number was an MMI code static final int CALL_STATUS_FAILED = 2; // The call failed // State of the Phone's audio modes // Each state can move to the other states, but within the state only certain // transitions for AudioManager.setMode() are allowed. static final int AUDIO_IDLE = 0; /** audio behaviour at phone idle */ static final int AUDIO_RINGING = 1; /** audio behaviour while ringing */ static final int AUDIO_OFFHOOK = 2; /** audio behaviour while in call. */ // USSD string length for MMI operations static final int MIN_USSD_LEN = 1; static final int MAX_USSD_LEN = 160; /** Speaker state, persisting between wired headset connection events */ private static boolean sIsSpeakerEnabled = false; /** Static handler for the connection/mute tracking */ private static ConnectionHandler mConnectionHandler; /** Phone state changed event*/ private static final int PHONE_STATE_CHANGED = -1; /** check status then decide whether answerCall */ private static final int MSG_CHECK_STATUS_ANSWERCALL = 100; /** poll phone DISCONNECTING status interval */ private static final int DISCONNECTING_POLLING_INTERVAL_MS = 200; /** poll phone DISCONNECTING status times limit */ private static final int DISCONNECTING_POLLING_TIMES_LIMIT = 8; /** Define for not a special CNAP string */ private static final int CNAP_SPECIAL_CASE_NO = -1; /** Noise suppression status as selected by user */ private static boolean sIsNoiseSuppressionEnabled = true; /** * Theme to use for dialogs displayed by utility methods in this class. This is needed * because these dialogs are displayed using the application context, which does not resolve * the dialog theme correctly. */ private static final int THEME = AlertDialog.THEME_DEVICE_DEFAULT_LIGHT; private static class FgRingCalls { private Call fgCall; private Call ringing; public FgRingCalls(Call fg, Call ring) { fgCall = fg; ringing = ring; } } /** USSD information used to aggregate all USSD messages */ private static AlertDialog sUssdDialog = null; private static StringBuilder sUssdMsg = new StringBuilder(); private static final ComponentName PSTN_CONNECTION_SERVICE_COMPONENT = new ComponentName("com.android.phone", "com.android.services.telephony.TelephonyConnectionService"); /** * Handler that tracks the connections and updates the value of the * Mute settings for each connection as needed. */ private static class ConnectionHandler extends Handler { @Override public void handleMessage(Message msg) { switch (msg.what) { case MSG_CHECK_STATUS_ANSWERCALL: FgRingCalls frC = (FgRingCalls) msg.obj; // wait for finishing disconnecting // before check the ringing call state if ((frC.fgCall != null) && (frC.fgCall.getState() == Call.State.DISCONNECTING) && (msg.arg1 < DISCONNECTING_POLLING_TIMES_LIMIT)) { Message retryMsg = mConnectionHandler.obtainMessage(MSG_CHECK_STATUS_ANSWERCALL); retryMsg.arg1 = 1 + msg.arg1; retryMsg.obj = msg.obj; mConnectionHandler.sendMessageDelayed(retryMsg, DISCONNECTING_POLLING_INTERVAL_MS); // since hangupActiveCall() also accepts the ringing call // check if the ringing call was already answered or not // only answer it when the call still is ringing } else if (frC.ringing.isRinging()) { if (msg.arg1 == DISCONNECTING_POLLING_TIMES_LIMIT) { Log.e(LOG_TAG, "DISCONNECTING time out"); } answerCall(frC.ringing); } break; } } } /** * Register the ConnectionHandler with the phone, to receive connection events */ public static void initializeConnectionHandler(CallManager cm) { if (mConnectionHandler == null) { mConnectionHandler = new ConnectionHandler(); } // pass over cm as user.obj cm.registerForPreciseCallStateChanged(mConnectionHandler, PHONE_STATE_CHANGED, cm); } /** This class is never instantiated. */ private PhoneUtils() { } /** * Answer the currently-ringing call. * * @return true if we answered the call, or false if there wasn't * actually a ringing incoming call, or some other error occurred. * * @see #answerAndEndHolding(CallManager, Call) * @see #answerAndEndActive(CallManager, Call) */ /* package */ static boolean answerCall(Call ringingCall) { log("answerCall(" + ringingCall + ")..."); final PhoneGlobals app = PhoneGlobals.getInstance(); final CallNotifier notifier = app.notifier; final Phone phone = ringingCall.getPhone(); final boolean phoneIsCdma = (phone.getPhoneType() == PhoneConstants.PHONE_TYPE_CDMA); boolean answered = false; IBluetoothHeadsetPhone btPhone = null; if (phoneIsCdma) { // Stop any signalInfo tone being played when a Call waiting gets answered if (ringingCall.getState() == Call.State.WAITING) { notifier.stopSignalInfoTone(); } } if (ringingCall != null && ringingCall.isRinging()) { if (DBG) log("answerCall: call state = " + ringingCall.getState()); try { if (phoneIsCdma) { if (app.cdmaPhoneCallState.getCurrentCallState() == CdmaPhoneCallState.PhoneCallState.IDLE) { // This is the FIRST incoming call being answered. // Set the Phone Call State to SINGLE_ACTIVE app.cdmaPhoneCallState.setCurrentCallState( CdmaPhoneCallState.PhoneCallState.SINGLE_ACTIVE); } else { // This is the CALL WAITING call being answered. // Set the Phone Call State to CONF_CALL app.cdmaPhoneCallState.setCurrentCallState( CdmaPhoneCallState.PhoneCallState.CONF_CALL); // Enable "Add Call" option after answering a Call Waiting as the user // should be allowed to add another call in case one of the parties // drops off app.cdmaPhoneCallState.setAddCallMenuStateAfterCallWaiting(true); } } final boolean isRealIncomingCall = isRealIncomingCall(ringingCall.getState()); //if (DBG) log("sPhone.acceptCall"); app.mCM.acceptCall(ringingCall); answered = true; setAudioMode(); } catch (CallStateException ex) { Log.w(LOG_TAG, "answerCall: caught " + ex, ex); if (phoneIsCdma) { // restore the cdmaPhoneCallState and btPhone.cdmaSetSecondCallState: app.cdmaPhoneCallState.setCurrentCallState( app.cdmaPhoneCallState.getPreviousCallState()); if (btPhone != null) { try { btPhone.cdmaSetSecondCallState(false); } catch (RemoteException e) { Log.e(LOG_TAG, Log.getStackTraceString(new Throwable())); } } } } } return answered; } /** * Hangs up all active calls. */ static void hangupAllCalls(CallManager cm) { final Call ringing = cm.getFirstActiveRingingCall(); final Call fg = cm.getActiveFgCall(); final Call bg = cm.getFirstActiveBgCall(); // We go in reverse order, BG->FG->RINGING because hanging up a ringing call or an active // call can move a bg call to a fg call which would force us to loop over each call // several times. This ordering works best to ensure we dont have any more calls. if (bg != null && !bg.isIdle()) { hangup(bg); } if (fg != null && !fg.isIdle()) { hangup(fg); } if (ringing != null && !ringing.isIdle()) { hangupRingingCall(fg); } } /** * Smart "hang up" helper method which hangs up exactly one connection, * based on the current Phone state, as follows: *
* IDLE -> SINGLE_ACTIVE * or * SINGLE_ACTIVE -> THRWAY_ACTIVE ** @param app The phone instance. */ private static void updateCdmaCallStateOnNewOutgoingCall(PhoneGlobals app, Connection connection) { if (app.cdmaPhoneCallState.getCurrentCallState() == CdmaPhoneCallState.PhoneCallState.IDLE) { // This is the first outgoing call. Set the Phone Call State to ACTIVE app.cdmaPhoneCallState.setCurrentCallState( CdmaPhoneCallState.PhoneCallState.SINGLE_ACTIVE); } else { // This is the second outgoing call. Set the Phone Call State to 3WAY app.cdmaPhoneCallState.setCurrentCallState( CdmaPhoneCallState.PhoneCallState.THRWAY_ACTIVE); // TODO: Remove this code. //app.getCallModeler().setCdmaOutgoing3WayCall(connection); } } /** * @see placeCall below */ public static int placeCall(Context context, Phone phone, String number, Uri contactRef, boolean isEmergencyCall) { return placeCall(context, phone, number, contactRef, isEmergencyCall, CallGatewayManager.EMPTY_INFO, null); } /** * Dial the number using the phone passed in. * * If the connection is establised, this method issues a sync call * that may block to query the caller info. * TODO: Change the logic to use the async query. * * @param context To perform the CallerInfo query. * @param phone the Phone object. * @param number to be dialed as requested by the user. This is * NOT the phone number to connect to. It is used only to build the * call card and to update the call log. See above for restrictions. * @param contactRef that triggered the call. Typically a 'tel:' * uri but can also be a 'content://contacts' one. * @param isEmergencyCall indicates that whether or not this is an * emergency call * @param gatewayUri Is the address used to setup the connection, null * if not using a gateway * @param callGateway Class for setting gateway data on a successful call. * * @return either CALL_STATUS_DIALED or CALL_STATUS_FAILED */ public static int placeCall(Context context, Phone phone, String number, Uri contactRef, boolean isEmergencyCall, RawGatewayInfo gatewayInfo, CallGatewayManager callGateway) { final Uri gatewayUri = gatewayInfo.gatewayUri; if (VDBG) { log("placeCall()... number: '" + number + "'" + ", GW:'" + gatewayUri + "'" + ", contactRef:" + contactRef + ", isEmergencyCall: " + isEmergencyCall); } else { log("placeCall()... number: " + toLogSafePhoneNumber(number) + ", GW: " + (gatewayUri != null ? "non-null" : "null") + ", emergency? " + isEmergencyCall); } final PhoneGlobals app = PhoneGlobals.getInstance(); boolean useGateway = false; if (null != gatewayUri && !isEmergencyCall && PhoneUtils.isRoutableViaGateway(number)) { // Filter out MMI, OTA and other codes. useGateway = true; } int status = CALL_STATUS_DIALED; Connection connection; String numberToDial; if (useGateway) { // TODO: 'tel' should be a constant defined in framework base // somewhere (it is in webkit.) if (null == gatewayUri || !PhoneAccount.SCHEME_TEL.equals(gatewayUri.getScheme())) { Log.e(LOG_TAG, "Unsupported URL:" + gatewayUri); return CALL_STATUS_FAILED; } // We can use getSchemeSpecificPart because we don't allow # // in the gateway numbers (treated a fragment delim.) However // if we allow more complex gateway numbers sequence (with // passwords or whatnot) that use #, this may break. // TODO: Need to support MMI codes. numberToDial = gatewayUri.getSchemeSpecificPart(); } else { numberToDial = number; } // Remember if the phone state was in IDLE state before this call. // After calling CallManager#dial(), getState() will return different state. final boolean initiallyIdle = app.mCM.getState() == PhoneConstants.State.IDLE; try { connection = app.mCM.dial(phone, numberToDial, VideoProfile.STATE_AUDIO_ONLY); } catch (CallStateException ex) { // CallStateException means a new outgoing call is not currently // possible: either no more call slots exist, or there's another // call already in the process of dialing or ringing. Log.w(LOG_TAG, "Exception from app.mCM.dial()", ex); return CALL_STATUS_FAILED; // Note that it's possible for CallManager.dial() to return // null *without* throwing an exception; that indicates that // we dialed an MMI (see below). } int phoneType = phone.getPhoneType(); // On GSM phones, null is returned for MMI codes if (null == connection) { status = CALL_STATUS_FAILED; } else { // Now that the call is successful, we can save the gateway info for the call if (callGateway != null) { callGateway.setGatewayInfoForConnection(connection, gatewayInfo); } if (phoneType == PhoneConstants.PHONE_TYPE_CDMA) { updateCdmaCallStateOnNewOutgoingCall(app, connection); } if (gatewayUri == null) { // phone.dial() succeeded: we're now in a normal phone call. // attach the URI to the CallerInfo Object if it is there, // otherwise just attach the Uri Reference. // if the uri does not have a "content" scheme, then we treat // it as if it does NOT have a unique reference. String content = context.getContentResolver().SCHEME_CONTENT; if ((contactRef != null) && (contactRef.getScheme().equals(content))) { Object userDataObject = connection.getUserData(); if (userDataObject == null) { connection.setUserData(contactRef); } else { // TODO: This branch is dead code, we have // just created the connection which has // no user data (null) by default. if (userDataObject instanceof CallerInfo) { ((CallerInfo) userDataObject).contactRefUri = contactRef; } else { ((CallerInfoToken) userDataObject).currentInfo.contactRefUri = contactRef; } } } } startGetCallerInfo(context, connection, null, null, gatewayInfo); setAudioMode(); } return status; } /* package */ static String toLogSafePhoneNumber(String number) { // For unknown number, log empty string. if (number == null) { return ""; } if (VDBG) { // When VDBG is true we emit PII. return number; } // Do exactly same thing as Uri#toSafeString() does, which will enable us to compare // sanitized phone numbers. StringBuilder builder = new StringBuilder(); for (int i = 0; i < number.length(); i++) { char c = number.charAt(i); if (c == '-' || c == '@' || c == '.') { builder.append(c); } else { builder.append('x'); } } return builder.toString(); } /** * Wrapper function to control when to send an empty Flash command to the network. * Mainly needed for CDMA networks, such as scenarios when we need to send a blank flash * to the network prior to placing a 3-way call for it to be successful. */ static void sendEmptyFlash(Phone phone) { if (phone.getPhoneType() == PhoneConstants.PHONE_TYPE_CDMA) { Call fgCall = phone.getForegroundCall(); if (fgCall.getState() == Call.State.ACTIVE) { // Send the empty flash if (DBG) Log.d(LOG_TAG, "onReceive: (CDMA) sending empty flash to network"); switchHoldingAndActive(phone.getBackgroundCall()); } } } static void swap() { final PhoneGlobals mApp = PhoneGlobals.getInstance(); if (!okToSwapCalls(mApp.mCM)) { // TODO: throw an error instead? return; } // Swap the fg and bg calls. // In the future we may provide some way for user to choose among // multiple background calls, for now, always act on the first background call. PhoneUtils.switchHoldingAndActive(mApp.mCM.getFirstActiveBgCall()); } /** * @param heldCall is the background call want to be swapped */ static void switchHoldingAndActive(Call heldCall) { log("switchHoldingAndActive()..."); try { CallManager cm = PhoneGlobals.getInstance().mCM; if (heldCall.isIdle()) { // no heldCall, so it is to hold active call cm.switchHoldingAndActive(cm.getFgPhone().getBackgroundCall()); } else { // has particular heldCall, so to switch cm.switchHoldingAndActive(heldCall); } setAudioMode(cm); } catch (CallStateException ex) { Log.w(LOG_TAG, "switchHoldingAndActive: caught " + ex, ex); } } static void mergeCalls() { mergeCalls(PhoneGlobals.getInstance().mCM); } static void mergeCalls(CallManager cm) { int phoneType = cm.getFgPhone().getPhoneType(); if (phoneType == PhoneConstants.PHONE_TYPE_CDMA) { log("mergeCalls(): CDMA..."); PhoneGlobals app = PhoneGlobals.getInstance(); if (app.cdmaPhoneCallState.getCurrentCallState() == CdmaPhoneCallState.PhoneCallState.THRWAY_ACTIVE) { // Set the Phone Call State to conference app.cdmaPhoneCallState.setCurrentCallState( CdmaPhoneCallState.PhoneCallState.CONF_CALL); // Send flash cmd // TODO: Need to change the call from switchHoldingAndActive to // something meaningful as we are not actually trying to swap calls but // instead are merging two calls by sending a Flash command. log("- sending flash..."); switchHoldingAndActive(cm.getFirstActiveBgCall()); } } else { try { log("mergeCalls(): calling cm.conference()..."); cm.conference(cm.getFirstActiveBgCall()); } catch (CallStateException ex) { Log.w(LOG_TAG, "mergeCalls: caught " + ex, ex); } } } static void separateCall(Connection c) { try { if (DBG) log("separateCall: " + toLogSafePhoneNumber(c.getAddress())); c.separate(); } catch (CallStateException ex) { Log.w(LOG_TAG, "separateCall: caught " + ex, ex); } } /** * Handle the MMIInitiate message and put up an alert that lets * the user cancel the operation, if applicable. * * @param context context to get strings. * @param mmiCode the MmiCode object being started. * @param buttonCallbackMessage message to post when button is clicked. * @param previousAlert a previous alert used in this activity. * @return the dialog handle */ static Dialog displayMMIInitiate(Context context, MmiCode mmiCode, Message buttonCallbackMessage, Dialog previousAlert) { if (DBG) log("displayMMIInitiate: " + mmiCode); if (previousAlert != null) { previousAlert.dismiss(); } // The UI paradigm we are using now requests that all dialogs have // user interaction, and that any other messages to the user should // be by way of Toasts. // // In adhering to this request, all MMI initiating "OK" dialogs // (non-cancelable MMIs) that end up being closed when the MMI // completes (thereby showing a completion dialog) are being // replaced with Toasts. // // As a side effect, moving to Toasts for the non-cancelable MMIs // also means that buttonCallbackMessage (which was tied into "OK") // is no longer invokable for these dialogs. This is not a problem // since the only callback messages we supported were for cancelable // MMIs anyway. // // A cancelable MMI is really just a USSD request. The term // "cancelable" here means that we can cancel the request when the // system prompts us for a response, NOT while the network is // processing the MMI request. Any request to cancel a USSD while // the network is NOT ready for a response may be ignored. // // With this in mind, we replace the cancelable alert dialog with // a progress dialog, displayed until we receive a request from // the the network. For more information, please see the comments // in the displayMMIComplete() method below. // // Anything that is NOT a USSD request is a normal MMI request, // which will bring up a toast (desribed above). boolean isCancelable = (mmiCode != null) && mmiCode.isCancelable(); if (!isCancelable) { if (DBG) log("not a USSD code, displaying status toast."); CharSequence text = context.getText(R.string.mmiStarted); Toast.makeText(context, text, Toast.LENGTH_SHORT) .show(); return null; } else { if (DBG) log("running USSD code, displaying indeterminate progress."); // create the indeterminate progress dialog and display it. ProgressDialog pd = new ProgressDialog(context, THEME); pd.setMessage(context.getText(R.string.ussdRunning)); pd.setCancelable(false); pd.setIndeterminate(true); pd.getWindow().addFlags(WindowManager.LayoutParams.FLAG_DIM_BEHIND); pd.show(); return pd; } } /** * Handle the MMIComplete message and fire off an intent to display * the message. * * @param context context to get strings. * @param mmiCode MMI result. * @param previousAlert a previous alert used in this activity. */ static void displayMMIComplete(final Phone phone, Context context, final MmiCode mmiCode, Message dismissCallbackMessage, AlertDialog previousAlert) { final PhoneGlobals app = PhoneGlobals.getInstance(); CharSequence text; int title = 0; // title for the progress dialog, if needed. MmiCode.State state = mmiCode.getState(); if (DBG) log("displayMMIComplete: state=" + state); switch (state) { case PENDING: // USSD code asking for feedback from user. text = mmiCode.getMessage(); if (DBG) log("- using text from PENDING MMI message: '" + text + "'"); break; case CANCELLED: text = null; break; case COMPLETE: if (app.getPUKEntryActivity() != null) { // if an attempt to unPUK the device was made, we specify // the title and the message here. title = com.android.internal.R.string.PinMmi; text = context.getText(R.string.puk_unlocked); break; } // All other conditions for the COMPLETE mmi state will cause // the case to fall through to message logic in common with // the FAILED case. case FAILED: text = mmiCode.getMessage(); if (DBG) log("- using text from MMI message: '" + text + "'"); break; default: throw new IllegalStateException("Unexpected MmiCode state: " + state); } if (previousAlert != null) { previousAlert.dismiss(); } // Check to see if a UI exists for the PUK activation. If it does // exist, then it indicates that we're trying to unblock the PUK. if ((app.getPUKEntryActivity() != null) && (state == MmiCode.State.COMPLETE)) { if (DBG) log("displaying PUK unblocking progress dialog."); // create the progress dialog, make sure the flags and type are // set correctly. ProgressDialog pd = new ProgressDialog(app, THEME); pd.setTitle(title); pd.setMessage(text); pd.setCancelable(false); pd.setIndeterminate(true); pd.getWindow().setType(WindowManager.LayoutParams.TYPE_SYSTEM_DIALOG); pd.getWindow().addFlags(WindowManager.LayoutParams.FLAG_DIM_BEHIND); // display the dialog pd.show(); // indicate to the Phone app that the progress dialog has // been assigned for the PUK unlock / SIM READY process. app.setPukEntryProgressDialog(pd); } else { // In case of failure to unlock, we'll need to reset the // PUK unlock activity, so that the user may try again. if (app.getPUKEntryActivity() != null) { app.setPukEntryActivity(null); } // A USSD in a pending state means that it is still // interacting with the user. if (state != MmiCode.State.PENDING) { if (DBG) log("MMI code has finished running."); if (DBG) log("Extended NW displayMMIInitiate (" + text + ")"); if (text == null || text.length() == 0) return; // displaying system alert dialog on the screen instead of // using another activity to display the message. This // places the message at the forefront of the UI. if (sUssdDialog == null) { sUssdDialog = new AlertDialog.Builder(context, THEME) .setPositiveButton(R.string.ok, null) .setCancelable(true) .setOnDismissListener(new DialogInterface.OnDismissListener() { @Override public void onDismiss(DialogInterface dialog) { sUssdMsg.setLength(0); } }) .create(); sUssdDialog.getWindow().setType( WindowManager.LayoutParams.TYPE_KEYGUARD_DIALOG); sUssdDialog.getWindow().addFlags( WindowManager.LayoutParams.FLAG_DIM_BEHIND); } if (sUssdMsg.length() != 0) { sUssdMsg .insert(0, "\n") .insert(0, app.getResources().getString(R.string.ussd_dialog_sep)) .insert(0, "\n"); } sUssdMsg.insert(0, text); sUssdDialog.setMessage(sUssdMsg.toString()); sUssdDialog.show(); } else { if (DBG) log("USSD code has requested user input. Constructing input dialog."); // USSD MMI code that is interacting with the user. The // basic set of steps is this: // 1. User enters a USSD request // 2. We recognize the request and displayMMIInitiate // (above) creates a progress dialog. // 3. Request returns and we get a PENDING or COMPLETE // message. // 4. These MMI messages are caught in the PhoneApp // (onMMIComplete) and the InCallScreen // (mHandler.handleMessage) which bring up this dialog // and closes the original progress dialog, // respectively. // 5. If the message is anything other than PENDING, // we are done, and the alert dialog (directly above) // displays the outcome. // 6. If the network is requesting more information from // the user, the MMI will be in a PENDING state, and // we display this dialog with the message. // 7. User input, or cancel requests result in a return // to step 1. Keep in mind that this is the only // time that a USSD should be canceled. // inflate the layout with the scrolling text area for the dialog. ContextThemeWrapper contextThemeWrapper = new ContextThemeWrapper(context, R.style.DialerAlertDialogTheme); LayoutInflater inflater = (LayoutInflater) contextThemeWrapper.getSystemService( Context.LAYOUT_INFLATER_SERVICE); View dialogView = inflater.inflate(R.layout.dialog_ussd_response, null); // get the input field. final EditText inputText = (EditText) dialogView.findViewById(R.id.input_field); // specify the dialog's click listener, with SEND and CANCEL logic. final DialogInterface.OnClickListener mUSSDDialogListener = new DialogInterface.OnClickListener() { public void onClick(DialogInterface dialog, int whichButton) { switch (whichButton) { case DialogInterface.BUTTON_POSITIVE: // As per spec 24.080, valid length of ussd string // is 1 - 160. If length is out of the range then // display toast message & Cancel MMI operation. if (inputText.length() < MIN_USSD_LEN || inputText.length() > MAX_USSD_LEN) { Toast.makeText(app, app.getResources().getString(R.string.enter_input, MIN_USSD_LEN, MAX_USSD_LEN), Toast.LENGTH_LONG).show(); if (mmiCode.isCancelable()) { mmiCode.cancel(); } } else { phone.sendUssdResponse(inputText.getText().toString()); } break; case DialogInterface.BUTTON_NEGATIVE: if (mmiCode.isCancelable()) { mmiCode.cancel(); } break; } } }; // build the dialog final AlertDialog newDialog = new AlertDialog.Builder(contextThemeWrapper) .setMessage(text) .setView(dialogView) .setPositiveButton(R.string.send_button, mUSSDDialogListener) .setNegativeButton(R.string.cancel, mUSSDDialogListener) .setCancelable(false) .create(); // attach the key listener to the dialog's input field and make // sure focus is set. final View.OnKeyListener mUSSDDialogInputListener = new View.OnKeyListener() { public boolean onKey(View v, int keyCode, KeyEvent event) { switch (keyCode) { case KeyEvent.KEYCODE_CALL: case KeyEvent.KEYCODE_ENTER: if(event.getAction() == KeyEvent.ACTION_DOWN) { phone.sendUssdResponse(inputText.getText().toString()); newDialog.dismiss(); } return true; } return false; } }; inputText.setOnKeyListener(mUSSDDialogInputListener); inputText.requestFocus(); // set the window properties of the dialog newDialog.getWindow().setType( WindowManager.LayoutParams.TYPE_SYSTEM_DIALOG); newDialog.getWindow().addFlags( WindowManager.LayoutParams.FLAG_DIM_BEHIND); // now show the dialog! newDialog.show(); newDialog.getButton(DialogInterface.BUTTON_POSITIVE) .setTextColor(context.getResources().getColor(R.color.dialer_theme_color)); newDialog.getButton(DialogInterface.BUTTON_NEGATIVE) .setTextColor(context.getResources().getColor(R.color.dialer_theme_color)); } } } /** * Cancels the current pending MMI operation, if applicable. * @return true if we canceled an MMI operation, or false * if the current pending MMI wasn't cancelable * or if there was no current pending MMI at all. * * @see displayMMIInitiate */ static boolean cancelMmiCode(Phone phone) { List extends MmiCode> pendingMmis = phone.getPendingMmiCodes(); int count = pendingMmis.size(); if (DBG) log("cancelMmiCode: num pending MMIs = " + count); boolean canceled = false; if (count > 0) { // assume that we only have one pending MMI operation active at a time. // I don't think it's possible to enter multiple MMI codes concurrently // in the phone UI, because during the MMI operation, an Alert panel // is displayed, which prevents more MMI code from being entered. MmiCode mmiCode = pendingMmis.get(0); if (mmiCode.isCancelable()) { mmiCode.cancel(); canceled = true; } } return canceled; } public static class VoiceMailNumberMissingException extends Exception { VoiceMailNumberMissingException() { super(); } VoiceMailNumberMissingException(String msg) { super(msg); } } /** * Given an Intent (which is presumably the ACTION_CALL intent that * initiated this outgoing call), figure out the actual phone number we * should dial. * * Note that the returned "number" may actually be a SIP address, * if the specified intent contains a sip: URI. * * This method is basically a wrapper around PhoneUtils.getNumberFromIntent(), * except it's also aware of the EXTRA_ACTUAL_NUMBER_TO_DIAL extra. * (That extra, if present, tells us the exact string to pass down to the * telephony layer. It's guaranteed to be safe to dial: it's either a PSTN * phone number with separators and keypad letters stripped out, or a raw * unencoded SIP address.) * * @return the phone number corresponding to the specified Intent, or null * if the Intent has no action or if the intent's data is malformed or * missing. * * @throws VoiceMailNumberMissingException if the intent * contains a "voicemail" URI, but there's no voicemail * number configured on the device. */ public static String getInitialNumber(Intent intent) throws PhoneUtils.VoiceMailNumberMissingException { if (DBG) log("getInitialNumber(): " + intent); String action = intent.getAction(); if (TextUtils.isEmpty(action)) { return null; } // If the EXTRA_ACTUAL_NUMBER_TO_DIAL extra is present, get the phone // number from there. (That extra takes precedence over the actual data // included in the intent.) if (intent.hasExtra(OutgoingCallBroadcaster.EXTRA_ACTUAL_NUMBER_TO_DIAL)) { String actualNumberToDial = intent.getStringExtra(OutgoingCallBroadcaster.EXTRA_ACTUAL_NUMBER_TO_DIAL); if (DBG) { log("==> got EXTRA_ACTUAL_NUMBER_TO_DIAL; returning '" + toLogSafePhoneNumber(actualNumberToDial) + "'"); } return actualNumberToDial; } return getNumberFromIntent(PhoneGlobals.getInstance(), intent); } /** * Gets the phone number to be called from an intent. Requires a Context * to access the contacts database, and a Phone to access the voicemail * number. * *
If phone
is null
, the function will return
* null
for voicemail:
URIs;
* if context
is null
, the function will return
* null
for person/phone URIs.
If the intent contains a sip:
URI, the returned
* "number" is actually the SIP address.
*
* @param context a context to use (or
* @param intent the intent
*
* @throws VoiceMailNumberMissingException if intent
contains
* a voicemail:
URI, but phone
does not
* have a voicemail number set.
*
* @return the phone number (or SIP address) that would be called by the intent,
* or null
if the number cannot be found.
*/
private static String getNumberFromIntent(Context context, Intent intent)
throws VoiceMailNumberMissingException {
Uri uri = intent.getData();
String scheme = uri.getScheme();
// The sip: scheme is simple: just treat the rest of the URI as a
// SIP address.
if (PhoneAccount.SCHEME_SIP.equals(scheme)) {
return uri.getSchemeSpecificPart();
}
// Otherwise, let PhoneNumberUtils.getNumberFromIntent() handle
// the other cases (i.e. tel: and voicemail: and contact: URIs.)
final String number = PhoneNumberUtils.getNumberFromIntent(intent, context);
// Check for a voicemail-dialing request. If the voicemail number is
// empty, throw a VoiceMailNumberMissingException.
if (PhoneAccount.SCHEME_VOICEMAIL.equals(scheme) &&
(number == null || TextUtils.isEmpty(number)))
throw new VoiceMailNumberMissingException();
return number;
}
/**
* Returns the caller-id info corresponding to the specified Connection.
* (This is just a simple wrapper around CallerInfo.getCallerInfo(): we
* extract a phone number from the specified Connection, and feed that
* number into CallerInfo.getCallerInfo().)
*
* The returned CallerInfo may be null in certain error cases, like if the
* specified Connection was null, or if we weren't able to get a valid
* phone number from the Connection.
*
* Finally, if the getCallerInfo() call did succeed, we save the resulting
* CallerInfo object in the "userData" field of the Connection.
*
* NOTE: This API should be avoided, with preference given to the
* asynchronous startGetCallerInfo API.
*/
static CallerInfo getCallerInfo(Context context, Connection c) {
CallerInfo info = null;
if (c != null) {
//See if there is a URI attached. If there is, this means
//that there is no CallerInfo queried yet, so we'll need to
//replace the URI with a full CallerInfo object.
Object userDataObject = c.getUserData();
if (userDataObject instanceof Uri) {
info = CallerInfo.getCallerInfo(context, (Uri) userDataObject);
if (info != null) {
c.setUserData(info);
}
} else {
if (userDataObject instanceof CallerInfoToken) {
//temporary result, while query is running
info = ((CallerInfoToken) userDataObject).currentInfo;
} else {
//final query result
info = (CallerInfo) userDataObject;
}
if (info == null) {
// No URI, or Existing CallerInfo, so we'll have to make do with
// querying a new CallerInfo using the connection's phone number.
String number = c.getAddress();
if (DBG) log("getCallerInfo: number = " + toLogSafePhoneNumber(number));
if (!TextUtils.isEmpty(number)) {
info = CallerInfo.getCallerInfo(context, number);
if (info != null) {
c.setUserData(info);
}
}
}
}
}
return info;
}
/**
* Class returned by the startGetCallerInfo call to package a temporary
* CallerInfo Object, to be superceded by the CallerInfo Object passed
* into the listener when the query with token mAsyncQueryToken is complete.
*/
public static class CallerInfoToken {
/**indicates that there will no longer be updates to this request.*/
public boolean isFinal;
public CallerInfo currentInfo;
public CallerInfoAsyncQuery asyncQuery;
}
/**
* Start a CallerInfo Query based on the earliest connection in the call.
*/
static CallerInfoToken startGetCallerInfo(Context context, Call call,
CallerInfoAsyncQuery.OnQueryCompleteListener listener, Object cookie) {
Connection conn = null;
int phoneType = call.getPhone().getPhoneType();
if (phoneType == PhoneConstants.PHONE_TYPE_CDMA) {
conn = call.getLatestConnection();
} else if ((phoneType == PhoneConstants.PHONE_TYPE_GSM)
|| (phoneType == PhoneConstants.PHONE_TYPE_SIP)
|| (phoneType == PhoneConstants.PHONE_TYPE_IMS)
|| (phoneType == PhoneConstants.PHONE_TYPE_THIRD_PARTY)) {
conn = call.getEarliestConnection();
} else {
throw new IllegalStateException("Unexpected phone type: " + phoneType);
}
return startGetCallerInfo(context, conn, listener, cookie);
}
static CallerInfoToken startGetCallerInfo(Context context, Connection c,
CallerInfoAsyncQuery.OnQueryCompleteListener listener, Object cookie) {
return startGetCallerInfo(context, c, listener, cookie, null);
}
/**
* place a temporary callerinfo object in the hands of the caller and notify
* caller when the actual query is done.
*/
static CallerInfoToken startGetCallerInfo(Context context, Connection c,
CallerInfoAsyncQuery.OnQueryCompleteListener listener, Object cookie,
RawGatewayInfo info) {
CallerInfoToken cit;
if (c == null) {
//TODO: perhaps throw an exception here.
cit = new CallerInfoToken();
cit.asyncQuery = null;
return cit;
}
Object userDataObject = c.getUserData();
// There are now 3 states for the Connection's userData object:
//
// (1) Uri - query has not been executed yet
//
// (2) CallerInfoToken - query is executing, but has not completed.
//
// (3) CallerInfo - query has executed.
//
// In each case we have slightly different behaviour:
// 1. If the query has not been executed yet (Uri or null), we start
// query execution asynchronously, and note it by attaching a
// CallerInfoToken as the userData.
// 2. If the query is executing (CallerInfoToken), we've essentially
// reached a state where we've received multiple requests for the
// same callerInfo. That means that once the query is complete,
// we'll need to execute the additional listener requested.
// 3. If the query has already been executed (CallerInfo), we just
// return the CallerInfo object as expected.
// 4. Regarding isFinal - there are cases where the CallerInfo object
// will not be attached, like when the number is empty (caller id
// blocking). This flag is used to indicate that the
// CallerInfoToken object is going to be permanent since no
// query results will be returned. In the case where a query
// has been completed, this flag is used to indicate to the caller
// that the data will not be updated since it is valid.
//
// Note: For the case where a number is NOT retrievable, we leave
// the CallerInfo as null in the CallerInfoToken. This is
// something of a departure from the original code, since the old
// code manufactured a CallerInfo object regardless of the query
// outcome. From now on, we will append an empty CallerInfo
// object, to mirror previous behaviour, and to avoid Null Pointer
// Exceptions.
if (userDataObject instanceof Uri) {
// State (1): query has not been executed yet
//create a dummy callerinfo, populate with what we know from URI.
cit = new CallerInfoToken();
cit.currentInfo = new CallerInfo();
cit.asyncQuery = CallerInfoAsyncQuery.startQuery(QUERY_TOKEN, context,
(Uri) userDataObject, sCallerInfoQueryListener, c);
cit.asyncQuery.addQueryListener(QUERY_TOKEN, listener, cookie);
cit.isFinal = false;
c.setUserData(cit);
if (DBG) log("startGetCallerInfo: query based on Uri: " + userDataObject);
} else if (userDataObject == null) {
// No URI, or Existing CallerInfo, so we'll have to make do with
// querying a new CallerInfo using the connection's phone number.
String number = c.getAddress();
if (info != null && info != CallGatewayManager.EMPTY_INFO) {
// Gateway number, the connection number is actually the gateway number.
// need to lookup via dialed number.
number = info.trueNumber;
}
if (DBG) {
log("PhoneUtils.startGetCallerInfo: new query for phone number...");
log("- number (address): " + toLogSafePhoneNumber(number));
log("- c: " + c);
log("- phone: " + c.getCall().getPhone());
int phoneType = c.getCall().getPhone().getPhoneType();
log("- phoneType: " + phoneType);
switch (phoneType) {
case PhoneConstants.PHONE_TYPE_NONE: log(" ==> PHONE_TYPE_NONE"); break;
case PhoneConstants.PHONE_TYPE_GSM: log(" ==> PHONE_TYPE_GSM"); break;
case PhoneConstants.PHONE_TYPE_IMS: log(" ==> PHONE_TYPE_IMS"); break;
case PhoneConstants.PHONE_TYPE_CDMA: log(" ==> PHONE_TYPE_CDMA"); break;
case PhoneConstants.PHONE_TYPE_SIP: log(" ==> PHONE_TYPE_SIP"); break;
case PhoneConstants.PHONE_TYPE_THIRD_PARTY:
log(" ==> PHONE_TYPE_THIRD_PARTY");
break;
default: log(" ==> Unknown phone type"); break;
}
}
cit = new CallerInfoToken();
cit.currentInfo = new CallerInfo();
// Store CNAP information retrieved from the Connection (we want to do this
// here regardless of whether the number is empty or not).
cit.currentInfo.cnapName = c.getCnapName();
cit.currentInfo.name = cit.currentInfo.cnapName; // This can still get overwritten
// by ContactInfo later
cit.currentInfo.numberPresentation = c.getNumberPresentation();
cit.currentInfo.namePresentation = c.getCnapNamePresentation();
if (VDBG) {
log("startGetCallerInfo: number = " + number);
log("startGetCallerInfo: CNAP Info from FW(1): name="
+ cit.currentInfo.cnapName
+ ", Name/Number Pres=" + cit.currentInfo.numberPresentation);
}
// handling case where number is null (caller id hidden) as well.
if (!TextUtils.isEmpty(number)) {
// Check for special CNAP cases and modify the CallerInfo accordingly
// to be sure we keep the right information to display/log later
number = modifyForSpecialCnapCases(context, cit.currentInfo, number,
cit.currentInfo.numberPresentation);
cit.currentInfo.phoneNumber = number;
// For scenarios where we may receive a valid number from the network but a
// restricted/unavailable presentation, we do not want to perform a contact query
// (see note on isFinal above). So we set isFinal to true here as well.
if (cit.currentInfo.numberPresentation != PhoneConstants.PRESENTATION_ALLOWED) {
cit.isFinal = true;
} else {
if (DBG) log("==> Actually starting CallerInfoAsyncQuery.startQuery()...");
cit.asyncQuery = CallerInfoAsyncQuery.startQuery(QUERY_TOKEN, context,
number, sCallerInfoQueryListener, c);
cit.asyncQuery.addQueryListener(QUERY_TOKEN, listener, cookie);
cit.isFinal = false;
}
} else {
// This is the case where we are querying on a number that
// is null or empty, like a caller whose caller id is
// blocked or empty (CLIR). The previous behaviour was to
// throw a null CallerInfo object back to the user, but
// this departure is somewhat cleaner.
if (DBG) log("startGetCallerInfo: No query to start, send trivial reply.");
cit.isFinal = true; // please see note on isFinal, above.
}
c.setUserData(cit);
if (DBG) {
log("startGetCallerInfo: query based on number: " + toLogSafePhoneNumber(number));
}
} else if (userDataObject instanceof CallerInfoToken) {
// State (2): query is executing, but has not completed.
// just tack on this listener to the queue.
cit = (CallerInfoToken) userDataObject;
// handling case where number is null (caller id hidden) as well.
if (cit.asyncQuery != null) {
cit.asyncQuery.addQueryListener(QUERY_TOKEN, listener, cookie);
if (DBG) log("startGetCallerInfo: query already running, adding listener: " +
listener.getClass().toString());
} else {
// handling case where number/name gets updated later on by the network
String updatedNumber = c.getAddress();
if (info != null) {
// Gateway number, the connection number is actually the gateway number.
// need to lookup via dialed number.
updatedNumber = info.trueNumber;
}
if (DBG) {
log("startGetCallerInfo: updatedNumber initially = "
+ toLogSafePhoneNumber(updatedNumber));
}
if (!TextUtils.isEmpty(updatedNumber)) {
// Store CNAP information retrieved from the Connection
cit.currentInfo.cnapName = c.getCnapName();
// This can still get overwritten by ContactInfo
cit.currentInfo.name = cit.currentInfo.cnapName;
cit.currentInfo.numberPresentation = c.getNumberPresentation();
cit.currentInfo.namePresentation = c.getCnapNamePresentation();
updatedNumber = modifyForSpecialCnapCases(context, cit.currentInfo,
updatedNumber, cit.currentInfo.numberPresentation);
cit.currentInfo.phoneNumber = updatedNumber;
if (DBG) {
log("startGetCallerInfo: updatedNumber="
+ toLogSafePhoneNumber(updatedNumber));
}
if (VDBG) {
log("startGetCallerInfo: CNAP Info from FW(2): name="
+ cit.currentInfo.cnapName
+ ", Name/Number Pres=" + cit.currentInfo.numberPresentation);
} else if (DBG) {
log("startGetCallerInfo: CNAP Info from FW(2)");
}
// For scenarios where we may receive a valid number from the network but a
// restricted/unavailable presentation, we do not want to perform a contact query
// (see note on isFinal above). So we set isFinal to true here as well.
if (cit.currentInfo.numberPresentation != PhoneConstants.PRESENTATION_ALLOWED) {
cit.isFinal = true;
} else {
cit.asyncQuery = CallerInfoAsyncQuery.startQuery(QUERY_TOKEN, context,
updatedNumber, sCallerInfoQueryListener, c);
cit.asyncQuery.addQueryListener(QUERY_TOKEN, listener, cookie);
cit.isFinal = false;
}
} else {
if (DBG) log("startGetCallerInfo: No query to attach to, send trivial reply.");
if (cit.currentInfo == null) {
cit.currentInfo = new CallerInfo();
}
// Store CNAP information retrieved from the Connection
cit.currentInfo.cnapName = c.getCnapName(); // This can still get
// overwritten by ContactInfo
cit.currentInfo.name = cit.currentInfo.cnapName;
cit.currentInfo.numberPresentation = c.getNumberPresentation();
cit.currentInfo.namePresentation = c.getCnapNamePresentation();
if (VDBG) {
log("startGetCallerInfo: CNAP Info from FW(3): name="
+ cit.currentInfo.cnapName
+ ", Name/Number Pres=" + cit.currentInfo.numberPresentation);
} else if (DBG) {
log("startGetCallerInfo: CNAP Info from FW(3)");
}
cit.isFinal = true; // please see note on isFinal, above.
}
}
} else {
// State (3): query is complete.
// The connection's userDataObject is a full-fledged
// CallerInfo instance. Wrap it in a CallerInfoToken and
// return it to the user.
cit = new CallerInfoToken();
cit.currentInfo = (CallerInfo) userDataObject;
cit.asyncQuery = null;
cit.isFinal = true;
// since the query is already done, call the listener.
if (DBG) log("startGetCallerInfo: query already done, returning CallerInfo");
if (DBG) log("==> cit.currentInfo = " + cit.currentInfo);
}
return cit;
}
/**
* Static CallerInfoAsyncQuery.OnQueryCompleteListener instance that
* we use with all our CallerInfoAsyncQuery.startQuery() requests.
*/
private static final int QUERY_TOKEN = -1;
static CallerInfoAsyncQuery.OnQueryCompleteListener sCallerInfoQueryListener =
new CallerInfoAsyncQuery.OnQueryCompleteListener () {
/**
* When the query completes, we stash the resulting CallerInfo
* object away in the Connection's "userData" (where it will
* later be retrieved by the in-call UI.)
*/
public void onQueryComplete(int token, Object cookie, CallerInfo ci) {
if (DBG) log("query complete, updating connection.userdata");
Connection conn = (Connection) cookie;
// Added a check if CallerInfo is coming from ContactInfo or from Connection.
// If no ContactInfo, then we want to use CNAP information coming from network
if (DBG) log("- onQueryComplete: CallerInfo:" + ci);
if (ci.contactExists || ci.isEmergencyNumber() || ci.isVoiceMailNumber()) {
// If the number presentation has not been set by
// the ContactInfo, use the one from the
// connection.
// TODO: Need a new util method to merge the info
// from the Connection in a CallerInfo object.
// Here 'ci' is a new CallerInfo instance read
// from the DB. It has lost all the connection
// info preset before the query (see PhoneUtils
// line 1334). We should have a method to merge
// back into this new instance the info from the
// connection object not set by the DB. If the
// Connection already has a CallerInfo instance in
// userData, then we could use this instance to
// fill 'ci' in. The same routine could be used in
// PhoneUtils.
if (0 == ci.numberPresentation) {
ci.numberPresentation = conn.getNumberPresentation();
}
} else {
// No matching contact was found for this number.
// Return a new CallerInfo based solely on the CNAP
// information from the network.
CallerInfo newCi = getCallerInfo(null, conn);
// ...but copy over the (few) things we care about
// from the original CallerInfo object:
if (newCi != null) {
newCi.phoneNumber = ci.phoneNumber; // To get formatted phone number
newCi.geoDescription = ci.geoDescription; // To get geo description string
ci = newCi;
}
}
if (DBG) log("==> Stashing CallerInfo " + ci + " into the connection...");
conn.setUserData(ci);
}
};
/**
* Returns a single "name" for the specified given a CallerInfo object.
* If the name is null, return defaultString as the default value, usually
* context.getString(R.string.unknown).
*/
static String getCompactNameFromCallerInfo(CallerInfo ci, Context context) {
if (DBG) log("getCompactNameFromCallerInfo: info = " + ci);
String compactName = null;
if (ci != null) {
if (TextUtils.isEmpty(ci.name)) {
// Perform any modifications for special CNAP cases to
// the phone number being displayed, if applicable.
compactName = modifyForSpecialCnapCases(context, ci, ci.phoneNumber,
ci.numberPresentation);
} else {
// Don't call modifyForSpecialCnapCases on regular name. See b/2160795.
compactName = ci.name;
}
}
if ((compactName == null) || (TextUtils.isEmpty(compactName))) {
// If we're still null/empty here, then check if we have a presentation
// string that takes precedence that we could return, otherwise display
// "unknown" string.
if (ci != null && ci.numberPresentation == PhoneConstants.PRESENTATION_RESTRICTED) {
compactName = context.getString(R.string.private_num);
} else if (ci != null && ci.numberPresentation == PhoneConstants.PRESENTATION_PAYPHONE) {
compactName = context.getString(R.string.payphone);
} else {
compactName = context.getString(R.string.unknown);
}
}
if (VDBG) log("getCompactNameFromCallerInfo: compactName=" + compactName);
return compactName;
}
/**
* Returns true if the specified Call is a "conference call", meaning
* that it owns more than one Connection object. This information is
* used to trigger certain UI changes that appear when a conference
* call is active (like displaying the label "Conference call", and
* enabling the "Manage conference" UI.)
*
* Watch out: This method simply checks the number of Connections,
* *not* their states. So if a Call has (for example) one ACTIVE
* connection and one DISCONNECTED connection, this method will return
* true (which is unintuitive, since the Call isn't *really* a
* conference call any more.)
*
* @return true if the specified call has more than one connection (in any state.)
*/
static boolean isConferenceCall(Call call) {
// CDMA phones don't have the same concept of "conference call" as
// GSM phones do; there's no special "conference call" state of
// the UI or a "manage conference" function. (Instead, when
// you're in a 3-way call, all we can do is display the "generic"
// state of the UI.) So as far as the in-call UI is concerned,
// Conference corresponds to generic display.
final PhoneGlobals app = PhoneGlobals.getInstance();
int phoneType = call.getPhone().getPhoneType();
if (phoneType == PhoneConstants.PHONE_TYPE_CDMA) {
CdmaPhoneCallState.PhoneCallState state = app.cdmaPhoneCallState.getCurrentCallState();
if ((state == CdmaPhoneCallState.PhoneCallState.CONF_CALL)
|| ((state == CdmaPhoneCallState.PhoneCallState.THRWAY_ACTIVE)
&& !app.cdmaPhoneCallState.IsThreeWayCallOrigStateDialing())) {
return true;
}
} else {
List