blob: 764894886eb804c33f0cdd82d7f704f7a1358683 [file] [log] [blame]
/*
* 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.KeyguardManager;
import android.app.ProgressDialog;
import android.content.ComponentName;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.ServiceConnection;
import android.media.AudioManager;
import android.net.Uri;
import android.os.AsyncResult;
import android.os.Handler;
import android.os.IBinder;
import android.os.Message;
import android.os.RemoteException;
import android.provider.Contacts;
import android.telephony.PhoneNumberUtils;
import android.text.TextUtils;
import android.util.Log;
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.CallStateException;
import com.android.internal.telephony.CallerInfo;
import com.android.internal.telephony.CallerInfoAsyncQuery;
import com.android.internal.telephony.Connection;
import com.android.internal.telephony.IExtendedNetworkService;
import com.android.internal.telephony.MmiCode;
import com.android.internal.telephony.Phone;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.List;
/**
* Misc utilities for the Phone app.
*/
public class PhoneUtils {
private static final String LOG_TAG = "PhoneUtils";
private static final boolean DBG = (PhoneApp.DBG_LEVEL >= 2);
/** 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. */
private static int sAudioBehaviourState = AUDIO_IDLE;
/** Speaker state, persisting between wired headset connection events */
private static boolean sIsSpeakerEnabled = false;
/** Hash table to store mute (Boolean) values based upon the connection.*/
private static Hashtable<Connection, Boolean> sConnectionMuteTable =
new Hashtable<Connection, Boolean>();
/** Static handler for the connection/mute tracking */
private static ConnectionHandler mConnectionHandler;
/** Phone state changed event*/
private static final int PHONE_STATE_CHANGED = -1;
// Extended network service interface instance
private static IExtendedNetworkService mNwService = null;
// used to cancel MMI command after 15 seconds timeout for NWService requirement
private static Message mMmiTimeoutCbMsg = null;
/**
* Handler that tracks the connections and updates the value of the
* Mute settings for each connection as needed.
*/
private static class ConnectionHandler extends Handler {
public void handleMessage(Message msg) {
AsyncResult ar = (AsyncResult) msg.obj;
switch (msg.what) {
case PHONE_STATE_CHANGED:
if (DBG) log("ConnectionHandler: updating mute state for each connection");
Phone phone = (Phone) ar.userObj;
// update the foreground connections, if there are new connections.
List<Connection> fgConnections = phone.getForegroundCall().getConnections();
for (Connection cn : fgConnections) {
if (sConnectionMuteTable.get(cn) == null) {
sConnectionMuteTable.put(cn, Boolean.FALSE);
}
}
// update the background connections, if there are new connections.
List<Connection> bgConnections = phone.getBackgroundCall().getConnections();
for (Connection cn : bgConnections) {
if (sConnectionMuteTable.get(cn) == null) {
sConnectionMuteTable.put(cn, Boolean.FALSE);
}
}
// Check to see if there are any lingering connections here
// (disconnected connections), use old-school iterators to avoid
// concurrent modification exceptions.
Connection cn;
for (Iterator<Connection> cnlist = sConnectionMuteTable.keySet().iterator();
cnlist.hasNext();) {
cn = cnlist.next();
if (!fgConnections.contains(cn) && !bgConnections.contains(cn)) {
if (DBG) log("connection: " + cn + "not accounted for, removing.");
cnlist.remove();
}
}
// Restore the mute state of the foreground call if we're not IDLE,
// otherwise just clear the mute state. This is really saying that
// as long as there is one or more connections, we should update
// the mute state with the earliest connection on the foreground
// call, and that with no connections, we should be back to a
// non-mute state.
if (phone.getState() != Phone.State.IDLE) {
restoreMuteState(phone);
} else {
setMuteInternal(phone, false);
}
break;
}
}
}
private static ServiceConnection ExtendedNetworkServiceConnection = new ServiceConnection() {
public void onServiceConnected(ComponentName name, IBinder iBinder) {
if (DBG) log("Extended NW onServiceConnected");
mNwService = IExtendedNetworkService.Stub.asInterface(iBinder);
}
public void onServiceDisconnected(ComponentName arg0) {
if (DBG) log("Extended NW onServiceDisconnected");
mNwService = null;
}
};
/**
* Register the ConnectionHandler with the phone, to receive connection events
*/
public static void initializeConnectionHandler(Phone phone) {
if (mConnectionHandler == null) {
mConnectionHandler = new ConnectionHandler();
}
phone.registerForPhoneStateChanged(mConnectionHandler, PHONE_STATE_CHANGED, phone);
// Extended NW service
Intent intent = new Intent("com.android.ussd.IExtendedNetworkService");
phone.getContext().bindService(intent,
ExtendedNetworkServiceConnection, Context.BIND_AUTO_CREATE);
if (DBG) log("Extended NW bindService IExtendedNetworkService");
}
/** This class is never instantiated. */
private PhoneUtils() {
}
//static method to set the audio control state.
static void setAudioControlState(int newState) {
sAudioBehaviourState = newState;
}
/**
* 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()
* @see answerAndEndActive()
*/
static boolean answerCall(Phone phone) {
if (DBG) log("answerCall()...");
// If the ringer is currently ringing and/or vibrating, stop it
// right now (before actually answering the call.)
PhoneApp.getInstance().getRinger().stopRing();
PhoneUtils.setAudioControlState(PhoneUtils.AUDIO_OFFHOOK);
boolean answered = false;
Call call = phone.getRingingCall();
if (call != null && call.isRinging()) {
if (DBG) log("answerCall: call state = " + call.getState());
try {
//if (DBG) log("sPhone.acceptCall");
phone.acceptCall();
answered = true;
setAudioMode(phone.getContext(), AudioManager.MODE_IN_CALL);
} catch (CallStateException ex) {
Log.w(LOG_TAG, "answerCall: caught " + ex, ex);
}
}
return answered;
}
/**
* Smart "hang up" helper method which hangs up exactly one connection,
* based on the current Phone state, as follows:
* <ul>
* <li>If there's a ringing call, hang that up.
* <li>Else if there's a foreground call, hang that up.
* <li>Else if there's a background call, hang that up.
* <li>Otherwise do nothing.
* </ul>
* @return true if we successfully hung up, or false
* if there were no active calls at all.
*/
static boolean hangup(Phone phone) {
boolean hungup = false;
Call ringing = phone.getRingingCall();
Call fg = phone.getForegroundCall();
Call bg = phone.getBackgroundCall();
if (!ringing.isIdle()) {
if (DBG) log("HANGUP ringing call");
hungup = hangup(ringing);
} else if (!fg.isIdle()) {
if (DBG) log("HANGUP foreground call");
hungup = hangup(fg);
} else if (!bg.isIdle()) {
if (DBG) log("HANGUP background call");
hungup = hangup(bg);
}
if (DBG) log("hungup=" + hungup);
return hungup;
}
static boolean hangupRingingCall(Phone phone) {
if (DBG) log("hangup ringing call");
return hangup(phone.getRingingCall());
}
static boolean hangupActiveCall(Phone phone) {
if (DBG) log("hangup active call");
return hangup(phone.getForegroundCall());
}
static boolean hangupHoldingCall(Phone phone) {
if (DBG) log("hangup holding call");
return hangup(phone.getBackgroundCall());
}
static boolean hangup(Call call) {
try {
call.hangup();
return true;
} catch (CallStateException ex) {
Log.e(LOG_TAG, "Call hangup: caught " + ex, ex);
}
return false;
}
static void hangup(Connection c) {
try {
if (c != null) {
c.hangup();
}
} catch (CallStateException ex) {
Log.w(LOG_TAG, "Connection hangup: caught " + ex, ex);
}
}
static boolean answerAndEndHolding(Phone phone) {
if (DBG) log("end holding & answer waiting: 1");
if (!hangupHoldingCall(phone)) {
Log.e(LOG_TAG, "end holding failed!");
return false;
}
if (DBG) log("end holding & answer waiting: 2");
return answerCall(phone);
}
static boolean answerAndEndActive(Phone phone) {
if (DBG) log("answerAndEndActive()...");
// Unlike the answerCall() method, we *don't* need to stop the
// ringer or change audio modes here since the user is already
// in-call, which means that the audio mode is already set
// correctly, and that we wouldn't have started the ringer in the
// first place.
// hanging up the active call also accepts the waiting call
return hangupActiveCall(phone);
}
/**
* Dial the number using the phone passed in.
*
* @param phone the Phone object.
* @param number the number to be dialed.
* @return either CALL_STATUS_DIALED, CALL_STATUS_DIALED_MMI, or CALL_STATUS_FAILED
*/
static int placeCall(Phone phone, String number, Uri contactRef) {
int status = CALL_STATUS_DIALED;
try {
if (DBG) log("placeCall: '" + number + "'...");
Connection cn = phone.dial(number);
if (DBG) log("===> phone.dial() returned: " + cn);
// Presently, null is returned for MMI codes
if (cn == null) {
if (DBG) log("dialed MMI code: " + number);
status = CALL_STATUS_DIALED_MMI;
// Set dialed MMI command to service
if (mNwService != null) {
try {
mNwService.setMmiString(number);
if (DBG) log("Extended NW bindService setUssdString (" + number + ")");
} catch (RemoteException e) {
mNwService = null;
}
}
} else {
PhoneUtils.setAudioControlState(PhoneUtils.AUDIO_OFFHOOK);
// 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 = phone.getContext().getContentResolver().SCHEME_CONTENT;
if ((contactRef != null) && (contactRef.getScheme().equals(content))) {
Object userDataObject = cn.getUserData();
if (userDataObject == null) {
cn.setUserData(contactRef);
} else {
if (userDataObject instanceof CallerInfo) {
((CallerInfo) userDataObject).contactRefUri = contactRef;
} else {
((CallerInfoToken) userDataObject).currentInfo.contactRefUri =
contactRef;
}
}
}
setAudioMode(phone.getContext(), AudioManager.MODE_IN_CALL);
}
} catch (CallStateException ex) {
Log.w(LOG_TAG, "PhoneUtils: Exception from phone.dial()", ex);
status = CALL_STATUS_FAILED;
}
return status;
}
static void switchHoldingAndActive(Phone phone) {
try {
if (DBG) log("switchHoldingAndActive");
phone.switchHoldingAndActive();
} catch (CallStateException ex) {
Log.w(LOG_TAG, "switchHoldingAndActive: caught " + ex, ex);
}
}
/**
* Restore the mute setting from the earliest connection of the
* foreground call.
*/
static Boolean restoreMuteState(Phone phone) {
//get the earliest connection
Connection c = phone.getForegroundCall().getEarliestConnection();
// only do this if connection is not null.
if (c != null) {
// retrieve the mute value.
Boolean shouldMute = sConnectionMuteTable.get(
phone.getForegroundCall().getEarliestConnection());
if (shouldMute == null) {
if (DBG) log("problem retrieving mute value for this connection.");
shouldMute = Boolean.FALSE;
}
// set the mute value and return the result.
setMute (phone, shouldMute.booleanValue());
return shouldMute;
}
return Boolean.valueOf(getMute (phone));
}
static void mergeCalls(Phone phone) {
try {
if (DBG) log("mergeCalls");
phone.conference();
} catch (CallStateException ex) {
Log.w(LOG_TAG, "mergeCalls: caught " + ex, ex);
}
}
static void separateCall(Connection c) {
try {
if (DBG) log("separateCall: " + 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).
// Optional code for Extended USSD running prompt
if (mNwService != null) {
if (DBG) log("running USSD code, displaying indeterminate progress.");
// create the indeterminate progress dialog and display it.
ProgressDialog pd = new ProgressDialog(context);
CharSequence textmsg = "";
try {
textmsg = mNwService.getMmiRunningText();
} catch (RemoteException e) {
mNwService = null;
textmsg = context.getText(R.string.ussdRunning);
}
if (DBG) log("Extended NW displayMMIInitiate (" + textmsg+ ")");
pd.setMessage(textmsg);
pd.setCancelable(false);
pd.setIndeterminate(true);
pd.getWindow().addFlags(WindowManager.LayoutParams.FLAG_DIM_BEHIND);
pd.getWindow().setType(WindowManager.LayoutParams.TYPE_SYSTEM_DIALOG);
pd.show();
// trigger a 15 seconds timeout to clear this progress dialog
mMmiTimeoutCbMsg = buttonCallbackMessage;
try {
mMmiTimeoutCbMsg.getTarget().sendMessageDelayed(buttonCallbackMessage, 15000);
} catch(NullPointerException e) {
mMmiTimeoutCbMsg = null;
}
return pd;
}
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);
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) {
CharSequence text;
int title = 0; // title for the progress dialog, if needed.
MmiCode.State state = mmiCode.getState();
if (DBG) log("displayMMIComplete: state=" + state);
// Clear timeout trigger message
if(mMmiTimeoutCbMsg != null) {
try{
mMmiTimeoutCbMsg.getTarget().removeMessages(mMmiTimeoutCbMsg.what);
if (DBG) log("Extended NW displayMMIComplete removeMsg");
} catch (NullPointerException e) {
}
mMmiTimeoutCbMsg = null;
}
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 = context.getText(R.string.mmiCancelled);
break;
case COMPLETE:
if (PhoneApp.getInstance().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.
PhoneApp app = PhoneApp.getInstance();
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);
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.");
// Replace response message with Extended Mmi wording
if (mNwService != null) {
try {
text = mNwService.getUserMessage(text);
} catch (RemoteException e) {
mNwService = null;
}
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.
AlertDialog newDialog = new AlertDialog.Builder(context)
.setMessage(text)
.setPositiveButton(R.string.ok, null)
.setCancelable(true)
.create();
newDialog.getWindow().setType(
WindowManager.LayoutParams.TYPE_SYSTEM_DIALOG);
newDialog.getWindow().addFlags(
WindowManager.LayoutParams.FLAG_DIM_BEHIND);
newDialog.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.
LayoutInflater inflater = (LayoutInflater) context.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.BUTTON1:
phone.sendUssdResponse(inputText.getText().toString());
break;
case DialogInterface.BUTTON2:
if (mmiCode.isCancelable()) {
mmiCode.cancel();
}
break;
}
}
};
// build the dialog
final AlertDialog newDialog = new AlertDialog.Builder(context)
.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:
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();
}
}
}
/**
* 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;
}
}
//clear timeout message and pre-set MMI command
if (mNwService != null) {
try {
mNwService.clearMmiString();
} catch (RemoteException e) {
mNwService = null;
}
}
if (mMmiTimeoutCbMsg != null) {
mMmiTimeoutCbMsg = null;
}
return canceled;
}
public static class VoiceMailNumberMissingException extends Exception {
VoiceMailNumberMissingException() {
super();
}
VoiceMailNumberMissingException(String msg) {
super(msg);
}
}
/**
* 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.
*
* <p>If <code>phone</code> is <code>null</code>, the function will return
* <code>null</code> for <code>voicemail:</code> URIs;
* if <code>context</code> is <code>null</code>, the function will return
* <code>null</code> for person/phone URIs.</p>
*
* @param context a context to use (or
* @param phone the phone on which the number would be called
* @param intent the intent
*
* @throws VoiceMailNumberMissingException if <code>intent</code> contains
* a <code>voicemail:</code> URI, but <code>phone</code> does not
* have a voicemail number set.
*
* @return the phone number that would be called by the intent,
* or <code>null</code> if the number cannot be found.
*/
static String getNumberFromIntent(Context context, Phone phone, Intent intent)
throws VoiceMailNumberMissingException {
final String number = PhoneNumberUtils.getNumberFromIntent(intent, context);
// Check for a voicemail-dailing request. If the voicemail number is
// empty, throw a VoiceMailNumberMissingException.
if (intent.getData().getScheme().equals("voicemail") &&
(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 = " + 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 = call.getEarliestConnection();
return startGetCallerInfo(context, conn, listener, cookie);
}
/**
* 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) {
CallerInfoToken cit;
if (c == null) {
//TODO: perhaps throw an exception here.
cit = new CallerInfoToken();
cit.asyncQuery = null;
return cit;
}
// There are now 3 states for the userdata.
// 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.
Object userDataObject = c.getUserData();
if (userDataObject instanceof Uri) {
//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();
cit = new CallerInfoToken();
cit.currentInfo = new CallerInfo();
if (DBG) log("startGetCallerInfo: number = " + number);
// handling case where number is null (caller id hidden) as well.
if (!TextUtils.isEmpty(number)) {
cit.currentInfo.phoneNumber = number;
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: " + number);
} else if (userDataObject instanceof CallerInfoToken) {
// query is running, 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 {
if (DBG) log("startGetCallerInfo: No query to attach to, send trivial reply.");
if (cit.currentInfo == null) {
cit.currentInfo = new CallerInfo();
}
cit.isFinal = true; // please see note on isFinal, above.
}
} else {
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");
}
return cit;
}
/**
* Implemented for CallerInfo.OnCallerInfoQueryCompleteListener interface.
* Updates the connection's userData when called.
*/
private static final int QUERY_TOKEN = -1;
static CallerInfoAsyncQuery.OnQueryCompleteListener sCallerInfoQueryListener =
new CallerInfoAsyncQuery.OnQueryCompleteListener () {
public void onQueryComplete(int token, Object cookie, CallerInfo ci){
if (DBG) log("query complete, updating connection.userdata");
((Connection) cookie).setUserData(ci);
}
};
static void saveToContact(Context context, String number) {
Intent intent = new Intent(Contacts.Intents.Insert.ACTION,
Contacts.People.CONTENT_URI);
intent.putExtra(Contacts.Intents.Insert.PHONE, number);
context.startActivity(intent);
}
/**
* Returns a single "name" for the specified Connection.
* This may be the caller name, the phone number, or a generic "unknown"
* string, depending on what info is available.
*
* NOTE: This API should be avoided, with preference given to the
* asynchronous startGetCallerInfo API, used in conjunction with
* getCompactNameFromCallerInfo().
*/
static String getCompactName(Context context, Connection conn) {
CallerInfo info = getCallerInfo(context, conn);
if (DBG) log("getCompactName: info = " + info);
String compactName = null;
if (info != null) {
compactName = info.name;
if (compactName == null) {
compactName = info.phoneNumber;
}
}
// TODO: figure out UNKNOWN, PRIVATE numbers?
if (compactName == null) {
compactName = context.getString(R.string.unknown);
}
return compactName;
}
/**
* Returns a single "name" for the specified Call.
* If the call only has a single connection, this is
* just like calling getCompactName() on that connection.
* But if this call has more than one connection,
* return a generic string like "Conference call".
*
* NOTE: This API should be avoided, with preference given to the
* asynchronous startGetCallerInfo API, used in conjunction with
* getCompactNameFromCallerInfo().
*/
static String getCompactName(Context context, Call call) {
if (isConferenceCall(call)) {
return context.getString(R.string.confCall);
}
Connection conn = call.getEarliestConnection(); // may be null
return getCompactName(context, conn); // OK if conn is null
}
/**
* 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) {
compactName = ci.name;
if (compactName == null) {
compactName = ci.phoneNumber;
}
}
// TODO: figure out UNKNOWN, PRIVATE numbers?
if (compactName == null) {
compactName = context.getString(R.string.unknown);
}
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,
// CDMA calls are *never* "conference calls".
if (PhoneApp.getInstance().phone.getPhoneName().equals("CDMA")) {
return false;
}
List<Connection> connections = call.getConnections();
if (connections != null && connections.size() > 1) {
return true;
}
return false;
// TODO: We may still want to change the semantics of this method
// to say that a given call is only really a conference call if
// the number of ACTIVE connections, not the total number of
// connections, is greater than one. (See warning comment in the
// javadoc above.)
// Here's an implementation of that:
// if (connections == null) {
// return false;
// }
// int numActiveConnections = 0;
// for (Connection conn : connections) {
// if (DBG) log(" - CONN: " + conn + ", state = " + conn.getState());
// if (conn.getState() == Call.State.ACTIVE) numActiveConnections++;
// if (numActiveConnections > 1) {
// return true;
// }
// }
// return false;
}
/**
* Launch the Dialer to start a new call.
* This is just a wrapper around the ACTION_DIAL intent.
*/
static void startNewCall(final Phone phone) {
final KeyguardManager keyguardManager = PhoneApp.getInstance().getKeyguardManager();
if (!keyguardManager.inKeyguardRestrictedInputMode()) {
internalStartNewCall(phone);
} else {
keyguardManager.exitKeyguardSecurely(new KeyguardManager.OnKeyguardExitResult() {
public void onKeyguardExitResult(boolean success) {
if (success) {
internalStartNewCall(phone);
}
}
});
}
}
private static void internalStartNewCall(Phone phone) {
// Sanity-check that this is OK given the current state of the phone.
if (!okToAddCall(phone)) {
Log.w(LOG_TAG, "startNewCall: can't add a new call in the current state");
dumpCallState(phone);
return;
}
// if applicable, mute the call while we're showing the add call UI.
if (!phone.getForegroundCall().isIdle()) {
setMuteInternal(phone, true);
// Inform the phone app that this mute state was NOT done
// voluntarily by the User.
PhoneApp.getInstance().setRestoreMuteOnInCallResume(true);
}
Intent intent = new Intent(Intent.ACTION_DIAL);
intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
// when we request the dialer come up, we also want to inform
// it that we're going through the "add call" option from the
// InCallScreen / PhoneUtils.
intent.putExtra(ADD_CALL_MODE_KEY, true);
PhoneApp.getInstance().startActivity(intent);
}
/**
* Brings up the UI used to handle an incoming call.
*
* Originally, this brought up an IncomingCallPanel instance
* (which was a subclass of Dialog) on top of whatever app
* was currently running. Now, we take you directly to the
* in-call screen, whose CallCard automatically does the right
* thing if there's a Call that's currently ringing.
*/
static void showIncomingCallUi() {
if (DBG) log("showIncomingCallUi()...");
PhoneApp app = PhoneApp.getInstance();
// Before bringing up the "incoming call" UI, force any system
// dialogs (like "recent tasks" or the power dialog) to close first.
app.sendBroadcast(new Intent(Intent.ACTION_CLOSE_SYSTEM_DIALOGS));
// Go directly to the in-call screen.
// (No need to do anything special if we're already on the in-call
// screen; it'll notice the phone state change and update itself.)
// But first, grab a full wake lock. We do this here, before we
// even fire off the InCallScreen intent, to make sure the
// ActivityManager doesn't try to pause the InCallScreen as soon
// as it comes up. (See bug 1648751.)
//
// And since the InCallScreen isn't visible yet (we haven't even
// fired off the intent yet), we DON'T want the screen to actually
// come on right now. So *before* acquiring the wake lock we need
// to call preventScreenOn(), which tells the PowerManager that
// the screen should stay off even if someone's holding a full
// wake lock. (This prevents any flicker during the "incoming
// call" sequence. The corresponding preventScreenOn(false) call
// will come from the InCallScreen when it's finally ready to be
// displayed.)
//
// TODO: this is all a temporary workaround. The real fix is to add
// an Activity attribute saying "this Activity wants to wake up the
// phone when it's displayed"; that way the ActivityManager could
// manage the wake locks *and* arrange for the screen to come on at
// the exact moment that the InCallScreen is ready to be displayed.
// (See bug 1648751.)
app.preventScreenOn(true);
app.requestWakeState(PhoneApp.WakeState.FULL);
// Fire off the InCallScreen intent.
app.displayCallScreen();
}
static void turnOnSpeaker(Context context, boolean flag) {
if (DBG) log("turnOnSpeaker: " + flag);
AudioManager audioManager = (AudioManager) context.getSystemService(Context.AUDIO_SERVICE);
audioManager.setSpeakerphoneOn(flag);
// record the speaker-enable value
sIsSpeakerEnabled = flag;
if (flag) {
NotificationMgr.getDefault().notifySpeakerphone();
} else {
NotificationMgr.getDefault().cancelSpeakerphone();
}
// We also need to make a fresh call to PhoneApp.updateWakeState()
// any time the speaker state changes, since the screen timeout is
// sometimes different depending on whether or not the speaker is
// in use.
PhoneApp app = PhoneApp.getInstance();
app.updateWakeState();
}
/**
* Restore the speaker mode, called after a wired headset disconnect
* event.
*/
static void restoreSpeakerMode(Context context) {
if (DBG) log("restoreSpeakerMode, restoring to: " + sIsSpeakerEnabled);
// change the mode if needed.
if (isSpeakerOn(context) != sIsSpeakerEnabled) {
turnOnSpeaker(context, sIsSpeakerEnabled);
}
}
static boolean isSpeakerOn(Context context) {
AudioManager audioManager = (AudioManager) context.getSystemService(Context.AUDIO_SERVICE);
return audioManager.isSpeakerphoneOn();
}
/**
* Wrapper around Phone.setMute() that also updates the mute icon in
* the status bar.
*
* All muting / unmuting from the in-call UI should go through this
* wrapper.
*/
static void setMute(Phone phone, boolean muted) {
// make the call to mute the audio
setMuteInternal(phone, muted);
// update the foreground connections to match. This includes
// all the connections on conference calls.
for (Connection cn : phone.getForegroundCall().getConnections()) {
if (sConnectionMuteTable.get(cn) == null) {
if (DBG) log("problem retrieving mute value for this connection.");
}
sConnectionMuteTable.put(cn, Boolean.valueOf(muted));
}
}
/**
* Internally used muting function. All UI calls should use {@link setMute}
*/
static void setMuteInternal(Phone phone, boolean muted) {
if (DBG) log("setMute: " + muted);
phone.setMute(muted);
if (muted) {
NotificationMgr.getDefault().notifyMute();
} else {
NotificationMgr.getDefault().cancelMute();
}
}
static boolean getMute(Phone phone) {
return phone.getMute();
}
/**
* A really simple wrapper around AudioManager.setMode(),
* with a bit of extra logging to help debug the exact
* timing (and call stacks) for all our setMode() calls.
*
* Also, add additional state monitoring to determine
* whether or not certain calls to change the audio mode
* are ignored.
*/
/* package */ static void setAudioMode(Context context, int mode) {
if (DBG) Log.d(LOG_TAG, "PhoneUtils.setAudioMode(" + audioModeToString(mode) + ")...");
//decide whether or not to ignore the audio setting
boolean ignore = false;
switch (sAudioBehaviourState) {
case AUDIO_RINGING:
ignore = ((mode == AudioManager.MODE_NORMAL) || (mode == AudioManager.MODE_IN_CALL));
break;
case AUDIO_OFFHOOK:
ignore = ((mode == AudioManager.MODE_NORMAL) || (mode == AudioManager.MODE_RINGTONE));
break;
case AUDIO_IDLE:
default:
ignore = (mode == AudioManager.MODE_IN_CALL);
break;
}
if (!ignore) {
AudioManager audioManager =
(AudioManager) context.getSystemService(Context.AUDIO_SERVICE);
// Enable stack dump only when actively debugging ("new Throwable()" is expensive!)
if (DBG_SETAUDIOMODE_STACK) Log.d(LOG_TAG, "Stack:", new Throwable("stack dump"));
audioManager.setMode(mode);
} else {
if (DBG) Log.d(LOG_TAG, "PhoneUtils.setAudioMode(), state is " + sAudioBehaviourState +
" ignoring " + audioModeToString(mode) + " request");
}
}
private static String audioModeToString(int mode) {
switch (mode) {
case AudioManager.MODE_INVALID: return "MODE_INVALID";
case AudioManager.MODE_CURRENT: return "MODE_CURRENT";
case AudioManager.MODE_NORMAL: return "MODE_NORMAL";
case AudioManager.MODE_RINGTONE: return "MODE_RINGTONE";
case AudioManager.MODE_IN_CALL: return "MODE_IN_CALL";
default: return String.valueOf(mode);
}
}
/**
* Handles the wired headset button while in-call.
*
* This is called from the PhoneApp, not from the InCallScreen,
* since the HEADSETHOOK button means "mute or unmute the current
* call" *any* time a call is active, even if the user isn't actually
* on the in-call screen.
*
* @return true if we consumed the event.
*/
/* package */ static boolean handleHeadsetHook(Phone phone) {
if (DBG) log("handleHeadsetHook()...");
// If the phone is totally idle, we ignore HEADSETHOOK events
// (and instead let them fall through to the media player.)
if (phone.getState() == Phone.State.IDLE) {
return false;
}
// Ok, the phone is in use.
// The headset button button means "Answer" if an incoming call is
// ringing. If not, it toggles the mute / unmute state.
//
// And in any case we *always* consume this event; this means
// that the usual mediaplayer-related behavior of the headset
// button will NEVER happen while the user is on a call.
final boolean hasRingingCall = !phone.getRingingCall().isIdle();
final boolean hasActiveCall = !phone.getForegroundCall().isIdle();
final boolean hasHoldingCall = !phone.getBackgroundCall().isIdle();
if (hasRingingCall) {
// If an incoming call is ringing, answer it (just like with the
// CALL button):
if (hasActiveCall && hasHoldingCall) {
if (DBG) log("handleHeadsetHook: ringing (both lines in use) ==> answer!");
answerAndEndActive(phone);
} else {
if (DBG) log("handleHeadsetHook: ringing ==> answer!");
answerCall(phone); // Automatically holds the current active call,
// if there is one
}
} else {
// No incoming ringing call. Toggle the mute state.
if (getMute(phone)) {
if (DBG) log("handleHeadsetHook: UNmuting...");
setMute(phone, false);
} else {
if (DBG) log("handleHeadsetHook: muting...");
setMute(phone, true);
}
}
// Even if the InCallScreen is the current activity, there's no
// need to force it to update, because (1) if we answered a
// ringing call, the InCallScreen will imminently get a phone
// state change event (causing an update), and (2) if we muted or
// unmuted, the setMute() call automagically updates the status
// bar, and there's no "mute" indication in the InCallScreen
// itself (other than the menu item, which only ever stays
// onscreen for a second anyway.)
return true;
}
/**
* Look for ANY connections on the phone that qualify as being
* disconnected.
*
* @return true if we find a connection that is disconnected over
* all the phone's call objects.
*/
/* package */ static boolean hasDisconnectedConnections(Phone phone) {
return hasDisconnectedConnections(phone.getForegroundCall()) ||
hasDisconnectedConnections(phone.getBackgroundCall()) ||
hasDisconnectedConnections(phone.getRingingCall());
}
/**
* Iterate over all connections in a call to see if there are any
* that are not alive (disconnected or idle).
*
* @return true if we find a connection that is disconnected, and
* pending removal via
* {@link com.android.internal.telephony.gsm.GsmCall#clearDisconnected()}.
*/
private static final boolean hasDisconnectedConnections(Call call) {
// look through all connections for non-active ones.
for (Connection c : call.getConnections()) {
if (!c.isAlive()) {
return true;
}
}
return false;
}
//
// Misc UI policy helper functions
//
/**
* @return true if we're allowed to swap calls, given the current
* state of the Phone.
*/
/* package */ static boolean okToSwapCalls(Phone phone) {
// "Swap" is available if both lines are in use and there's no
// incoming call. (Actually we need to verify that the active
// call really is in the ACTIVE state and the holding call really
// is in the HOLDING state, since you *can't* actually swap calls
// when the foreground call is DIALING or ALERTING.)
// TODO(CDMA): Need to handle the CDMA case too.
return phone.getRingingCall().isIdle()
&& (phone.getForegroundCall().getState() == Call.State.ACTIVE)
&& (phone.getBackgroundCall().getState() == Call.State.HOLDING);
}
/**
* @return true if we're allowed to merge calls, given the current
* state of the Phone.
*/
/* package */ static boolean okToMergeCalls(Phone phone) {
// "Merge" is available if both lines are in use and there's no
// incoming call, *and* the current conference isn't already
// "full".
// TODO(CDMA): Need to handle the CDMA case too.
return phone.getRingingCall().isIdle() && phone.canConference();
}
/**
* @return true if the UI should let you add a new call, given the current
* state of the Phone.
*/
/* package */ static boolean okToAddCall(Phone phone) {
// "Add call" is available only if ALL of the following are true:
// - There's no incoming ringing call
// - There's < 2 lines in use
// - The foreground call is ACTIVE or IDLE or DISCONNECTED.
// (We mainly need to make sure it *isn't* DIALING or ALERTING.)
// TODO(CDMA): Need to handle the CDMA case too.
final boolean hasRingingCall = !phone.getRingingCall().isIdle();
final boolean hasActiveCall = !phone.getForegroundCall().isIdle();
final boolean hasHoldingCall = !phone.getBackgroundCall().isIdle();
final boolean allLinesTaken = hasActiveCall && hasHoldingCall;
final Call.State fgCallState = phone.getForegroundCall().getState();
return !hasRingingCall
&& !allLinesTaken
&& ((fgCallState == Call.State.ACTIVE)
|| (fgCallState == Call.State.IDLE)
|| (fgCallState == Call.State.DISCONNECTED));
}
//
// General phone and call state debugging/testing code
//
/* package */ static void dumpCallState(Phone phone) {
Log.d(LOG_TAG, "##### dumpCallState()");
Log.d(LOG_TAG, "- Phone: " + phone + ", name = " + phone.getPhoneName()
+ ", state = " + phone.getState());
Log.d(LOG_TAG, "-");
Call fgCall = phone.getForegroundCall();
Log.d(LOG_TAG, "- FG call: " + fgCall);
Log.d(LOG_TAG, "- state: " + fgCall.getState());
Log.d(LOG_TAG, "- isAlive(): " + fgCall.getState().isAlive());
Log.d(LOG_TAG, "- isRinging(): " + fgCall.getState().isRinging());
Log.d(LOG_TAG, "- isDialing(): " + fgCall.getState().isDialing());
Log.d(LOG_TAG, "- isIdle(): " + fgCall.isIdle());
Log.d(LOG_TAG, "- hasConnections: " + fgCall.hasConnections());
Log.d(LOG_TAG, "-");
Call bgCall = phone.getBackgroundCall();
Log.d(LOG_TAG, "- BG call: " + bgCall);
Log.d(LOG_TAG, "- state: " + bgCall.getState());
Log.d(LOG_TAG, "- isAlive(): " + bgCall.getState().isAlive());
Log.d(LOG_TAG, "- isRinging(): " + bgCall.getState().isRinging());
Log.d(LOG_TAG, "- isDialing(): " + bgCall.getState().isDialing());
Log.d(LOG_TAG, "- isIdle(): " + bgCall.isIdle());
Log.d(LOG_TAG, "- hasConnections: " + bgCall.hasConnections());
Log.d(LOG_TAG, "-");
Call ringingCall = phone.getRingingCall();
Log.d(LOG_TAG, "- RINGING call: " + ringingCall);
Log.d(LOG_TAG, "- state: " + ringingCall.getState());
Log.d(LOG_TAG, "- isAlive(): " + ringingCall.getState().isAlive());
Log.d(LOG_TAG, "- isRinging(): " + ringingCall.getState().isRinging());
Log.d(LOG_TAG, "- isDialing(): " + ringingCall.getState().isDialing());
Log.d(LOG_TAG, "- isIdle(): " + ringingCall.isIdle());
Log.d(LOG_TAG, "- hasConnections: " + ringingCall.hasConnections());
Log.d(LOG_TAG, "-");
final boolean hasRingingCall = !phone.getRingingCall().isIdle();
final boolean hasActiveCall = !phone.getForegroundCall().isIdle();
final boolean hasHoldingCall = !phone.getBackgroundCall().isIdle();
final boolean allLinesTaken = hasActiveCall && hasHoldingCall;
Log.d(LOG_TAG, "- hasRingingCall: " + hasRingingCall);
Log.d(LOG_TAG, "- hasActiveCall: " + hasActiveCall);
Log.d(LOG_TAG, "- hasHoldingCall: " + hasHoldingCall);
Log.d(LOG_TAG, "- allLinesTaken: " + allLinesTaken);
// Watch out: the isRinging() call below does NOT tell us anything
// about the state of the telephony layer; it merely tells us whether
// the Ringer manager is currently playing the ringtone.
boolean ringing = PhoneApp.getInstance().getRinger().isRinging();
Log.d(LOG_TAG, "- ringing (Ringer manager state): " + ringing);
Log.d(LOG_TAG, "-----");
}
private static void log(String msg) {
Log.d(LOG_TAG, msg);
}
}