/*
* 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.internal.telephony.cdma;
import android.content.Context;
import android.os.AsyncResult;
import android.os.Handler;
import android.os.Message;
import android.os.Registrant;
import android.os.RegistrantList;
import android.telephony.DisconnectCause;
import android.telephony.PhoneNumberUtils;
import android.telephony.ServiceState;
import android.telephony.Rlog;
import android.telephony.TelephonyManager;
import android.os.SystemProperties;
import android.text.TextUtils;
import com.android.internal.telephony.CallStateException;
import com.android.internal.telephony.CallTracker;
import com.android.internal.telephony.CommandsInterface;
import com.android.internal.telephony.Connection;
import com.android.internal.telephony.DriverCall;
import com.android.internal.telephony.Phone;
import com.android.internal.telephony.PhoneBase;
import com.android.internal.telephony.PhoneConstants;
import com.android.internal.telephony.TelephonyProperties;
import com.android.internal.telephony.imsphone.ImsPhone;
import com.android.internal.telephony.imsphone.ImsPhoneConnection;
import java.io.FileDescriptor;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.List;
/**
* {@hide}
*/
public final class CdmaCallTracker extends CallTracker {
static final String LOG_TAG = "CdmaCallTracker";
private static final boolean REPEAT_POLLING = false;
private static final boolean DBG_POLL = false;
//***** Constants
static final int MAX_CONNECTIONS = 8;
static final int MAX_CONNECTIONS_PER_CALL = 1; // only 1 connection allowed per call
//***** Instance Variables
CdmaConnection mConnections[] = new CdmaConnection[MAX_CONNECTIONS];
RegistrantList mVoiceCallEndedRegistrants = new RegistrantList();
RegistrantList mVoiceCallStartedRegistrants = new RegistrantList();
RegistrantList mCallWaitingRegistrants = new RegistrantList();
// connections dropped during last poll
ArrayList<CdmaConnection> mDroppedDuringPoll
= new ArrayList<CdmaConnection>(MAX_CONNECTIONS);
CdmaCall mRingingCall = new CdmaCall(this);
// A call that is ringing or (call) waiting
CdmaCall mForegroundCall = new CdmaCall(this);
CdmaCall mBackgroundCall = new CdmaCall(this);
CdmaConnection mPendingMO;
boolean mHangupPendingMO;
boolean mPendingCallInEcm=false;
boolean mIsInEmergencyCall = false;
CDMAPhone mPhone;
boolean mDesiredMute = false; // false = mute off
int mPendingCallClirMode;
PhoneConstants.State mState = PhoneConstants.State.IDLE;
private boolean mIsEcmTimerCanceled = false;
private int m3WayCallFlashDelay = 0;
// boolean needsPoll;
//***** Events
//***** Constructors
CdmaCallTracker(CDMAPhone phone) {
mPhone = phone;
mCi = phone.mCi;
mCi.registerForCallStateChanged(this, EVENT_CALL_STATE_CHANGE, null);
mCi.registerForOn(this, EVENT_RADIO_AVAILABLE, null);
mCi.registerForNotAvailable(this, EVENT_RADIO_NOT_AVAILABLE, null);
mCi.registerForCallWaitingInfo(this, EVENT_CALL_WAITING_INFO_CDMA, null);
mForegroundCall.setGeneric(false);
}
public void dispose() {
Rlog.d(LOG_TAG, "CdmaCallTracker dispose");
mCi.unregisterForLineControlInfo(this);
mCi.unregisterForCallStateChanged(this);
mCi.unregisterForOn(this);
mCi.unregisterForNotAvailable(this);
mCi.unregisterForCallWaitingInfo(this);
clearDisconnected();
}
@Override
protected void finalize() {
Rlog.d(LOG_TAG, "CdmaCallTracker finalized");
}
//***** Instance Methods
//***** Public Methods
@Override
public void registerForVoiceCallStarted(Handler h, int what, Object obj) {
Registrant r = new Registrant(h, what, obj);
mVoiceCallStartedRegistrants.add(r);
// Notify if in call when registering
if (mState != PhoneConstants.State.IDLE) {
r.notifyRegistrant(new AsyncResult(null, null, null));
}
}
@Override
public void unregisterForVoiceCallStarted(Handler h) {
mVoiceCallStartedRegistrants.remove(h);
}
@Override
public void registerForVoiceCallEnded(Handler h, int what, Object obj) {
Registrant r = new Registrant(h, what, obj);
mVoiceCallEndedRegistrants.add(r);
}
@Override
public void unregisterForVoiceCallEnded(Handler h) {
mVoiceCallEndedRegistrants.remove(h);
}
public void registerForCallWaiting(Handler h, int what, Object obj) {
Registrant r = new Registrant (h, what, obj);
mCallWaitingRegistrants.add(r);
}
public void unregisterForCallWaiting(Handler h) {
mCallWaitingRegistrants.remove(h);
}
/**
* clirMode is one of the CLIR_ constants
*/
Connection
dial (String dialString, int clirMode) throws CallStateException {
// note that this triggers call state changed notif
clearDisconnected();
if (!canDial()) {
throw new CallStateException("cannot dial in current state");
}
TelephonyManager tm =
(TelephonyManager) mPhone.getContext().getSystemService(Context.TELEPHONY_SERVICE);
String origNumber = dialString;
String operatorIsoContry = tm.getNetworkCountryIsoForPhone(mPhone.getPhoneId());
String simIsoContry = tm.getSimCountryIsoForPhone(mPhone.getPhoneId());
boolean internationalRoaming = !TextUtils.isEmpty(operatorIsoContry)
&& !TextUtils.isEmpty(simIsoContry)
&& !simIsoContry.equals(operatorIsoContry);
if (internationalRoaming) {
if ("us".equals(simIsoContry)) {
internationalRoaming = internationalRoaming && !"vi".equals(operatorIsoContry);
} else if ("vi".equals(simIsoContry)) {
internationalRoaming = internationalRoaming && !"us".equals(operatorIsoContry);
}
}
if (internationalRoaming) {
dialString = convertNumberIfNecessary(mPhone, dialString);
}
String inEcm=SystemProperties.get(TelephonyProperties.PROPERTY_INECM_MODE, "false");
boolean isPhoneInEcmMode = inEcm.equals("true");
boolean isEmergencyCall =
PhoneNumberUtils.isLocalEmergencyNumber(mPhone.getContext(), dialString);
// Cancel Ecm timer if a second emergency call is originating in Ecm mode
if (isPhoneInEcmMode && isEmergencyCall) {
handleEcmTimer(CDMAPhone.CANCEL_ECM_TIMER);
}
// We are initiating a call therefore even if we previously
// didn't know the state (i.e. Generic was true) we now know
// and therefore can set Generic to false.
mForegroundCall.setGeneric(false);
// The new call must be assigned to the foreground call.
// That call must be idle, so place anything that's
// there on hold
if (mForegroundCall.getState() == CdmaCall.State.ACTIVE) {
return dialThreeWay(dialString);
}
mPendingMO = new CdmaConnection(mPhone.getContext(), checkForTestEmergencyNumber(dialString),
this, mForegroundCall);
mHangupPendingMO = false;
if ( mPendingMO.getAddress() == null || mPendingMO.getAddress().length() == 0
|| mPendingMO.getAddress().indexOf(PhoneNumberUtils.WILD) >= 0 ) {
// Phone number is invalid
mPendingMO.mCause = DisconnectCause.INVALID_NUMBER;
// handlePollCalls() will notice this call not present
// and will mark it as dropped.
pollCallsWhenSafe();
} else {
// Always unmute when initiating a new call
setMute(false);
// Check data call
disableDataCallInEmergencyCall(dialString);
// In Ecm mode, if another emergency call is dialed, Ecm mode will not exit.
if(!isPhoneInEcmMode || (isPhoneInEcmMode && isEmergencyCall)) {
mCi.dial(mPendingMO.getAddress(), clirMode, obtainCompleteMessage());
} else {
mPhone.exitEmergencyCallbackMode();
mPhone.setOnEcbModeExitResponse(this,EVENT_EXIT_ECM_RESPONSE_CDMA, null);
mPendingCallClirMode=clirMode;
mPendingCallInEcm=true;
}
}
if (mNumberConverted) {
mPendingMO.setConverted(origNumber);
mNumberConverted = false;
}
updatePhoneState();
mPhone.notifyPreciseCallStateChanged();
return mPendingMO;
}
Connection
dial (String dialString) throws CallStateException {
return dial(dialString, CommandsInterface.CLIR_DEFAULT);
}
private Connection
dialThreeWay (String dialString) {
if (!mForegroundCall.isIdle()) {
// Check data call
disableDataCallInEmergencyCall(dialString);
// Attach the new connection to foregroundCall
mPendingMO = new CdmaConnection(mPhone.getContext(),
checkForTestEmergencyNumber(dialString), this, mForegroundCall);
// Some network need a empty flash before sending the normal one
m3WayCallFlashDelay = mPhone.getContext().getResources()
.getInteger(com.android.internal.R.integer.config_cdma_3waycall_flash_delay);
if (m3WayCallFlashDelay > 0) {
mCi.sendCDMAFeatureCode("", obtainMessage(EVENT_THREE_WAY_DIAL_BLANK_FLASH));
} else {
mCi.sendCDMAFeatureCode(mPendingMO.getAddress(),
obtainMessage(EVENT_THREE_WAY_DIAL_L2_RESULT_CDMA));
}
return mPendingMO;
}
return null;
}
void
acceptCall() throws CallStateException {
if (mRingingCall.getState() == CdmaCall.State.INCOMING) {
Rlog.i("phone", "acceptCall: incoming...");
// Always unmute when answering a new call
setMute(false);
mCi.acceptCall(obtainCompleteMessage());
} else if (mRingingCall.getState() == CdmaCall.State.WAITING) {
CdmaConnection cwConn = (CdmaConnection)(mRingingCall.getLatestConnection());
// Since there is no network response for supplimentary
// service for CDMA, we assume call waiting is answered.
// ringing Call state change to idle is in CdmaCall.detach
// triggered by updateParent.
cwConn.updateParent(mRingingCall, mForegroundCall);
cwConn.onConnectedInOrOut();
updatePhoneState();
switchWaitingOrHoldingAndActive();
} else {
throw new CallStateException("phone not ringing");
}
}
void
rejectCall () throws CallStateException {
// AT+CHLD=0 means "release held or UDUB"
// so if the phone isn't ringing, this could hang up held
if (mRingingCall.getState().isRinging()) {
mCi.rejectCall(obtainCompleteMessage());
} else {
throw new CallStateException("phone not ringing");
}
}
void
switchWaitingOrHoldingAndActive() throws CallStateException {
// Should we bother with this check?
if (mRingingCall.getState() == CdmaCall.State.INCOMING) {
throw new CallStateException("cannot be in the incoming state");
} else if (mForegroundCall.getConnections().size() > 1) {
flashAndSetGenericTrue();
} else {
// Send a flash command to CDMA network for putting the other party on hold.
// For CDMA networks which do not support this the user would just hear a beep
// from the network. For CDMA networks which do support it will put the other
// party on hold.
mCi.sendCDMAFeatureCode("", obtainMessage(EVENT_SWITCH_RESULT));
}
}
void
conference() {
// Should we be checking state?
flashAndSetGenericTrue();
}
void
explicitCallTransfer() {
mCi.explicitCallTransfer(obtainCompleteMessage(EVENT_ECT_RESULT));
}
void
clearDisconnected() {
internalClearDisconnected();
updatePhoneState();
mPhone.notifyPreciseCallStateChanged();
}
boolean
canConference() {
return mForegroundCall.getState() == CdmaCall.State.ACTIVE
&& mBackgroundCall.getState() == CdmaCall.State.HOLDING
&& !mBackgroundCall.isFull()
&& !mForegroundCall.isFull();
}
boolean
canDial() {
boolean ret;
int serviceState = mPhone.getServiceState().getState();
String disableCall = SystemProperties.get(
TelephonyProperties.PROPERTY_DISABLE_CALL, "false");
ret = (serviceState != ServiceState.STATE_POWER_OFF)
&& mPendingMO == null
&& !mRingingCall.isRinging()
&& !disableCall.equals("true")
&& (!mForegroundCall.getState().isAlive()
|| (mForegroundCall.getState() == CdmaCall.State.ACTIVE)
|| !mBackgroundCall.getState().isAlive());
if (!ret) {
log(String.format("canDial is false\n" +
"((serviceState=%d) != ServiceState.STATE_POWER_OFF)::=%s\n" +
"&& pendingMO == null::=%s\n" +
"&& !ringingCall.isRinging()::=%s\n" +
"&& !disableCall.equals(\"true\")::=%s\n" +
"&& (!foregroundCall.getState().isAlive()::=%s\n" +
" || foregroundCall.getState() == CdmaCall.State.ACTIVE::=%s\n" +
" ||!backgroundCall.getState().isAlive())::=%s)",
serviceState,
serviceState != ServiceState.STATE_POWER_OFF,
mPendingMO == null,
!mRingingCall.isRinging(),
!disableCall.equals("true"),
!mForegroundCall.getState().isAlive(),
mForegroundCall.getState() == CdmaCall.State.ACTIVE,
!mBackgroundCall.getState().isAlive()));
}
return ret;
}
boolean
canTransfer() {
Rlog.e(LOG_TAG, "canTransfer: not possible in CDMA");
return false;
}
//***** Private Instance Methods
private void
internalClearDisconnected() {
mRingingCall.clearDisconnected();
mForegroundCall.clearDisconnected();
mBackgroundCall.clearDisconnected();
}
/**
* Obtain a message to use for signalling "invoke getCurrentCalls() when
* this operation and all other pending operations are complete
*/
private Message
obtainCompleteMessage() {
return obtainCompleteMessage(EVENT_OPERATION_COMPLETE);
}
/**
* Obtain a message to use for signalling "invoke getCurrentCalls() when
* this operation and all other pending operations are complete
*/
private Message
obtainCompleteMessage(int what) {
mPendingOperations++;
mLastRelevantPoll = null;
mNeedsPoll = true;
if (DBG_POLL) log("obtainCompleteMessage: pendingOperations=" +
mPendingOperations + ", needsPoll=" + mNeedsPoll);
return obtainMessage(what);
}
private void
operationComplete() {
mPendingOperations--;
if (DBG_POLL) log("operationComplete: pendingOperations=" +
mPendingOperations + ", needsPoll=" + mNeedsPoll);
if (mPendingOperations == 0 && mNeedsPoll) {
mLastRelevantPoll = obtainMessage(EVENT_POLL_CALLS_RESULT);
mCi.getCurrentCalls(mLastRelevantPoll);
} else if (mPendingOperations < 0) {
// this should never happen
Rlog.e(LOG_TAG,"CdmaCallTracker.pendingOperations < 0");
mPendingOperations = 0;
}
}
private void
updatePhoneState() {
PhoneConstants.State oldState = mState;
if (mRingingCall.isRinging()) {
mState = PhoneConstants.State.RINGING;
} else if (mPendingMO != null ||
!(mForegroundCall.isIdle() && mBackgroundCall.isIdle())) {
mState = PhoneConstants.State.OFFHOOK;
} else {
ImsPhone imsPhone = (ImsPhone)mPhone.getImsPhone();
if ( mState == PhoneConstants.State.OFFHOOK && (imsPhone != null)){
imsPhone.callEndCleanupHandOverCallIfAny();
}
mState = PhoneConstants.State.IDLE;
}
if (mState == PhoneConstants.State.IDLE && oldState != mState) {
mVoiceCallEndedRegistrants.notifyRegistrants(
new AsyncResult(null, null, null));
} else if (oldState == PhoneConstants.State.IDLE && oldState != mState) {
mVoiceCallStartedRegistrants.notifyRegistrants (
new AsyncResult(null, null, null));
}
if (Phone.DEBUG_PHONE) {
log("update phone state, old=" + oldState + " new="+ mState);
}
if (mState != oldState) {
mPhone.notifyPhoneStateChanged();
}
}
// ***** Overwritten from CallTracker
@Override
protected void
handlePollCalls(AsyncResult ar) {
List polledCalls;
if (ar.exception == null) {
polledCalls = (List)ar.result;
} else if (isCommandExceptionRadioNotAvailable(ar.exception)) {
// just a dummy empty ArrayList to cause the loop
// to hang up all the calls
polledCalls = new ArrayList();
} else {
// Radio probably wasn't ready--try again in a bit
// But don't keep polling if the channel is closed
pollCallsAfterDelay();
return;
}
Connection newRinging = null; //or waiting
Connection newUnknown = null;
boolean hasNonHangupStateChanged = false; // Any change besides
// a dropped connection
boolean hasAnyCallDisconnected = false;
boolean needsPollDelay = false;
boolean unknownConnectionAppeared = false;
for (int i = 0, curDC = 0, dcSize = polledCalls.size()
; i < mConnections.length; i++) {
CdmaConnection conn = mConnections[i];
DriverCall dc = null;
// polledCall list is sparse
if (curDC < dcSize) {
dc = (DriverCall) polledCalls.get(curDC);
if (dc.index == i+1) {
curDC++;
} else {
dc = null;
}
}
if (DBG_POLL) log("poll: conn[i=" + i + "]=" +
conn+", dc=" + dc);
if (conn == null && dc != null) {
// Connection appeared in CLCC response that we don't know about
if (mPendingMO != null && mPendingMO.compareTo(dc)) {
if (DBG_POLL) log("poll: pendingMO=" + mPendingMO);
// It's our pending mobile originating call
mConnections[i] = mPendingMO;
mPendingMO.mIndex = i;
mPendingMO.update(dc);
mPendingMO = null;
// Someone has already asked to hangup this call
if (mHangupPendingMO) {
mHangupPendingMO = false;
// Re-start Ecm timer when an uncompleted emergency call ends
if (mIsEcmTimerCanceled) {
handleEcmTimer(CDMAPhone.RESTART_ECM_TIMER);
}
try {
if (Phone.DEBUG_PHONE) log(
"poll: hangupPendingMO, hangup conn " + i);
hangup(mConnections[i]);
} catch (CallStateException ex) {
Rlog.e(LOG_TAG, "unexpected error on hangup");
}
// Do not continue processing this poll
// Wait for hangup and repoll
return;
}
} else {
if (Phone.DEBUG_PHONE) {
log("pendingMo=" + mPendingMO + ", dc=" + dc);
}
mConnections[i] = new CdmaConnection(mPhone.getContext(), dc, this, i);
Connection hoConnection = getHoConnection(dc);
if (hoConnection != null) {
// Single Radio Voice Call Continuity (SRVCC) completed
mConnections[i].migrateFrom(hoConnection);
mHandoverConnections.remove(hoConnection);
mPhone.notifyHandoverStateChanged(mConnections[i]);
} else {
// find if the MT call is a new ring or unknown connection
newRinging = checkMtFindNewRinging(dc,i);
if (newRinging == null) {
unknownConnectionAppeared = true;
newUnknown = mConnections[i];
}
}
checkAndEnableDataCallAfterEmergencyCallDropped();
}
hasNonHangupStateChanged = true;
} else if (conn != null && dc == null) {
// This case means the RIL has no more active call anymore and
// we need to clean up the foregroundCall and ringingCall.
// Loop through foreground call connections as
// it contains the known logical connections.
int count = mForegroundCall.mConnections.size();
for (int n = 0; n < count; n++) {
if (Phone.DEBUG_PHONE) log("adding fgCall cn " + n + " to droppedDuringPoll");
CdmaConnection cn = (CdmaConnection)mForegroundCall.mConnections.get(n);
mDroppedDuringPoll.add(cn);
}
count = mRingingCall.mConnections.size();
// Loop through ringing call connections as
// it may contain the known logical connections.
for (int n = 0; n < count; n++) {
if (Phone.DEBUG_PHONE) log("adding rgCall cn " + n + " to droppedDuringPoll");
CdmaConnection cn = (CdmaConnection)mRingingCall.mConnections.get(n);
mDroppedDuringPoll.add(cn);
}
mForegroundCall.setGeneric(false);
mRingingCall.setGeneric(false);
// Re-start Ecm timer when the connected emergency call ends
if (mIsEcmTimerCanceled) {
handleEcmTimer(CDMAPhone.RESTART_ECM_TIMER);
}
// If emergency call is not going through while dialing
checkAndEnableDataCallAfterEmergencyCallDropped();
// Dropped connections are removed from the CallTracker
// list but kept in the Call list
mConnections[i] = null;
} else if (conn != null && dc != null) { /* implicit conn.compareTo(dc) */
// Call collision case
if (conn.isIncoming() != dc.isMT) {
if (dc.isMT == true){
// Mt call takes precedence than Mo,drops Mo
mDroppedDuringPoll.add(conn);
// find if the MT call is a new ring or unknown connection
newRinging = checkMtFindNewRinging(dc,i);
if (newRinging == null) {
unknownConnectionAppeared = true;
newUnknown = conn;
}
checkAndEnableDataCallAfterEmergencyCallDropped();
} else {
// Call info stored in conn is not consistent with the call info from dc.
// We should follow the rule of MT calls taking precedence over MO calls
// when there is conflict, so here we drop the call info from dc and
// continue to use the call info from conn, and only take a log.
Rlog.e(LOG_TAG,"Error in RIL, Phantom call appeared " + dc);
}
} else {
boolean changed;
changed = conn.update(dc);
hasNonHangupStateChanged = hasNonHangupStateChanged || changed;
}
}
if (REPEAT_POLLING) {
if (dc != null) {
// FIXME with RIL, we should not need this anymore
if ((dc.state == DriverCall.State.DIALING
/*&& cm.getOption(cm.OPTION_POLL_DIALING)*/)
|| (dc.state == DriverCall.State.ALERTING
/*&& cm.getOption(cm.OPTION_POLL_ALERTING)*/)
|| (dc.state == DriverCall.State.INCOMING
/*&& cm.getOption(cm.OPTION_POLL_INCOMING)*/)
|| (dc.state == DriverCall.State.WAITING
/*&& cm.getOption(cm.OPTION_POLL_WAITING)*/)
) {
// Sometimes there's no unsolicited notification
// for state transitions
needsPollDelay = true;
}
}
}
}
// This is the first poll after an ATD.
// We expect the pending call to appear in the list
// If it does not, we land here
if (mPendingMO != null) {
Rlog.d(LOG_TAG,"Pending MO dropped before poll fg state:"
+ mForegroundCall.getState());
mDroppedDuringPoll.add(mPendingMO);
mPendingMO = null;
mHangupPendingMO = false;
if( mPendingCallInEcm) {
mPendingCallInEcm = false;
}
}
if (newRinging != null) {
mPhone.notifyNewRingingConnection(newRinging);
}
// clear the "local hangup" and "missed/rejected call"
// cases from the "dropped during poll" list
// These cases need no "last call fail" reason
for (int i = mDroppedDuringPoll.size() - 1; i >= 0 ; i--) {
CdmaConnection conn = mDroppedDuringPoll.get(i);
if (conn.isIncoming() && conn.getConnectTime() == 0) {
// Missed or rejected call
int cause;
if (conn.mCause == DisconnectCause.LOCAL) {
cause = DisconnectCause.INCOMING_REJECTED;
} else {
cause = DisconnectCause.INCOMING_MISSED;
}
if (Phone.DEBUG_PHONE) {
log("missed/rejected call, conn.cause=" + conn.mCause);
log("setting cause to " + cause);
}
mDroppedDuringPoll.remove(i);
hasAnyCallDisconnected |= conn.onDisconnect(cause);
} else if (conn.mCause == DisconnectCause.LOCAL
|| conn.mCause == DisconnectCause.INVALID_NUMBER) {
mDroppedDuringPoll.remove(i);
hasAnyCallDisconnected |= conn.onDisconnect(conn.mCause);
}
}
/* Disconnect any pending Handover connections */
for (Connection hoConnection : mHandoverConnections) {
log("handlePollCalls - disconnect hoConn= " + hoConnection.toString());
((ImsPhoneConnection)hoConnection).onDisconnect(DisconnectCause.NOT_VALID);
mHandoverConnections.remove(hoConnection);
}
// Any non-local disconnects: determine cause
if (mDroppedDuringPoll.size() > 0) {
mCi.getLastCallFailCause(
obtainNoPollCompleteMessage(EVENT_GET_LAST_CALL_FAIL_CAUSE));
}
if (needsPollDelay) {
pollCallsAfterDelay();
}
// Cases when we can no longer keep disconnected Connection's
// with their previous calls
// 1) the phone has started to ring
// 2) A Call/Connection object has changed state...
// we may have switched or held or answered (but not hung up)
if (newRinging != null || hasNonHangupStateChanged || hasAnyCallDisconnected) {
internalClearDisconnected();
}
updatePhoneState();
if (unknownConnectionAppeared) {
mPhone.notifyUnknownConnection(newUnknown);
}
if (hasNonHangupStateChanged || newRinging != null || hasAnyCallDisconnected) {
mPhone.notifyPreciseCallStateChanged();
}
//dumpState();
}
//***** Called from CdmaConnection
/*package*/ void
hangup (CdmaConnection conn) throws CallStateException {
if (conn.mOwner != this) {
throw new CallStateException ("CdmaConnection " + conn
+ "does not belong to CdmaCallTracker " + this);
}
if (conn == mPendingMO) {
// We're hanging up an outgoing call that doesn't have it's
// GSM index assigned yet
if (Phone.DEBUG_PHONE) log("hangup: set hangupPendingMO to true");
mHangupPendingMO = true;
} else if ((conn.getCall() == mRingingCall)
&& (mRingingCall.getState() == CdmaCall.State.WAITING)) {
// Handle call waiting hang up case.
//
// The ringingCall state will change to IDLE in CdmaCall.detach
// if the ringing call connection size is 0. We don't specifically
// set the ringing call state to IDLE here to avoid a race condition
// where a new call waiting could get a hang up from an old call
// waiting ringingCall.
//
// PhoneApp does the call log itself since only PhoneApp knows
// the hangup reason is user ignoring or timing out. So conn.onDisconnect()
// is not called here. Instead, conn.onLocalDisconnect() is called.
conn.onLocalDisconnect();
updatePhoneState();
mPhone.notifyPreciseCallStateChanged();
return;
} else {
try {
mCi.hangupConnection (conn.getCDMAIndex(), obtainCompleteMessage());
} catch (CallStateException ex) {
// Ignore "connection not found"
// Call may have hung up already
Rlog.w(LOG_TAG,"CdmaCallTracker WARN: hangup() on absent connection "
+ conn);
}
}
conn.onHangupLocal();
}
/*package*/ void
separate (CdmaConnection conn) throws CallStateException {
if (conn.mOwner != this) {
throw new CallStateException ("CdmaConnection " + conn
+ "does not belong to CdmaCallTracker " + this);
}
try {
mCi.separateConnection (conn.getCDMAIndex(),
obtainCompleteMessage(EVENT_SEPARATE_RESULT));
} catch (CallStateException ex) {
// Ignore "connection not found"
// Call may have hung up already
Rlog.w(LOG_TAG,"CdmaCallTracker WARN: separate() on absent connection "
+ conn);
}
}
//***** Called from CDMAPhone
/*package*/ void
setMute(boolean mute) {
mDesiredMute = mute;
mCi.setMute(mDesiredMute, null);
}
/*package*/ boolean
getMute() {
return mDesiredMute;
}
//***** Called from CdmaCall
/* package */ void
hangup (CdmaCall call) throws CallStateException {
if (call.getConnections().size() == 0) {
throw new CallStateException("no connections in call");
}
if (call == mRingingCall) {
if (Phone.DEBUG_PHONE) log("(ringing) hangup waiting or background");
mCi.hangupWaitingOrBackground(obtainCompleteMessage());
} else if (call == mForegroundCall) {
if (call.isDialingOrAlerting()) {
if (Phone.DEBUG_PHONE) {
log("(foregnd) hangup dialing or alerting...");
}
hangup((CdmaConnection)(call.getConnections().get(0)));
} else {
hangupForegroundResumeBackground();
}
} else if (call == mBackgroundCall) {
if (mRingingCall.isRinging()) {
if (Phone.DEBUG_PHONE) {
log("hangup all conns in background call");
}
hangupAllConnections(call);
} else {
hangupWaitingOrBackground();
}
} else {
throw new RuntimeException ("CdmaCall " + call +
"does not belong to CdmaCallTracker " + this);
}
call.onHangupLocal();
mPhone.notifyPreciseCallStateChanged();
}
/* package */
void hangupWaitingOrBackground() {
if (Phone.DEBUG_PHONE) log("hangupWaitingOrBackground");
mCi.hangupWaitingOrBackground(obtainCompleteMessage());
}
/* package */
void hangupForegroundResumeBackground() {
if (Phone.DEBUG_PHONE) log("hangupForegroundResumeBackground");
mCi.hangupForegroundResumeBackground(obtainCompleteMessage());
}
void hangupConnectionByIndex(CdmaCall call, int index)
throws CallStateException {
int count = call.mConnections.size();
for (int i = 0; i < count; i++) {
CdmaConnection cn = (CdmaConnection)call.mConnections.get(i);
if (cn.getCDMAIndex() == index) {
mCi.hangupConnection(index, obtainCompleteMessage());
return;
}
}
throw new CallStateException("no gsm index found");
}
void hangupAllConnections(CdmaCall call) {
try {
int count = call.mConnections.size();
for (int i = 0; i < count; i++) {
CdmaConnection cn = (CdmaConnection)call.mConnections.get(i);
mCi.hangupConnection(cn.getCDMAIndex(), obtainCompleteMessage());
}
} catch (CallStateException ex) {
Rlog.e(LOG_TAG, "hangupConnectionByIndex caught " + ex);
}
}
/* package */
CdmaConnection getConnectionByIndex(CdmaCall call, int index)
throws CallStateException {
int count = call.mConnections.size();
for (int i = 0; i < count; i++) {
CdmaConnection cn = (CdmaConnection)call.mConnections.get(i);
if (cn.getCDMAIndex() == index) {
return cn;
}
}
return null;
}
private void flashAndSetGenericTrue() {
mCi.sendCDMAFeatureCode("", obtainMessage(EVENT_SWITCH_RESULT));
// Set generic to true because in CDMA it is not known what
// the status of the call is after a call waiting is answered,
// 3 way call merged or a switch between calls.
mForegroundCall.setGeneric(true);
mPhone.notifyPreciseCallStateChanged();
}
private void handleRadioNotAvailable() {
// handlePollCalls will clear out its
// call list when it gets the CommandException
// error result from this
pollCallsWhenSafe();
}
private void notifyCallWaitingInfo(CdmaCallWaitingNotification obj) {
if (mCallWaitingRegistrants != null) {
mCallWaitingRegistrants.notifyRegistrants(new AsyncResult(null, obj, null));
}
}
private void handleCallWaitingInfo (CdmaCallWaitingNotification cw) {
// Check how many connections in foregroundCall.
// If the connection in foregroundCall is more
// than one, then the connection information is
// not reliable anymore since it means either
// call waiting is connected or 3 way call is
// dialed before, so set generic.
if (mForegroundCall.mConnections.size() > 1 ) {
mForegroundCall.setGeneric(true);
}
// Create a new CdmaConnection which attaches itself to ringingCall.
mRingingCall.setGeneric(false);
new CdmaConnection(mPhone.getContext(), cw, this, mRingingCall);
updatePhoneState();
// Finally notify application
notifyCallWaitingInfo(cw);
}
//****** Overridden from Handler
@Override
public void
handleMessage (Message msg) {
AsyncResult ar;
if (!mPhone.mIsTheCurrentActivePhone) {
Rlog.w(LOG_TAG, "Ignoring events received on inactive CdmaPhone");
return;
}
switch (msg.what) {
case EVENT_POLL_CALLS_RESULT:{
Rlog.d(LOG_TAG, "Event EVENT_POLL_CALLS_RESULT Received");
ar = (AsyncResult)msg.obj;
if(msg == mLastRelevantPoll) {
if(DBG_POLL) log(
"handle EVENT_POLL_CALL_RESULT: set needsPoll=F");
mNeedsPoll = false;
mLastRelevantPoll = null;
handlePollCalls((AsyncResult)msg.obj);
}
}
break;
case EVENT_OPERATION_COMPLETE:
operationComplete();
break;
case EVENT_SWITCH_RESULT:
// In GSM call operationComplete() here which gets the
// current call list. But in CDMA there is no list so
// there is nothing to do.
break;
case EVENT_GET_LAST_CALL_FAIL_CAUSE:
int causeCode;
ar = (AsyncResult)msg.obj;
operationComplete();
if (ar.exception != null) {
// An exception occurred...just treat the disconnect
// cause as "normal"
causeCode = CallFailCause.NORMAL_CLEARING;
Rlog.i(LOG_TAG,
"Exception during getLastCallFailCause, assuming normal disconnect");
} else {
causeCode = ((int[])ar.result)[0];
}
for (int i = 0, s = mDroppedDuringPoll.size()
; i < s ; i++
) {
CdmaConnection conn = mDroppedDuringPoll.get(i);
conn.onRemoteDisconnect(causeCode);
}
updatePhoneState();
mPhone.notifyPreciseCallStateChanged();
mDroppedDuringPoll.clear();
break;
case EVENT_REPOLL_AFTER_DELAY:
case EVENT_CALL_STATE_CHANGE:
pollCallsWhenSafe();
break;
case EVENT_RADIO_AVAILABLE:
handleRadioAvailable();
break;
case EVENT_RADIO_NOT_AVAILABLE:
handleRadioNotAvailable();
break;
case EVENT_EXIT_ECM_RESPONSE_CDMA:
// no matter the result, we still do the same here
if (mPendingCallInEcm) {
mCi.dial(mPendingMO.getAddress(), mPendingCallClirMode, obtainCompleteMessage());
mPendingCallInEcm = false;
}
mPhone.unsetOnEcbModeExitResponse(this);
break;
case EVENT_CALL_WAITING_INFO_CDMA:
ar = (AsyncResult)msg.obj;
if (ar.exception == null) {
handleCallWaitingInfo((CdmaCallWaitingNotification)ar.result);
Rlog.d(LOG_TAG, "Event EVENT_CALL_WAITING_INFO_CDMA Received");
}
break;
case EVENT_THREE_WAY_DIAL_L2_RESULT_CDMA:
ar = (AsyncResult)msg.obj;
if (ar.exception == null) {
// Assume 3 way call is connected
mPendingMO.onConnectedInOrOut();
mPendingMO = null;
}
break;
case EVENT_THREE_WAY_DIAL_BLANK_FLASH:
ar = (AsyncResult) msg.obj;
if (ar.exception == null) {
postDelayed(
new Runnable() {
public void run() {
if (mPendingMO != null) {
mCi.sendCDMAFeatureCode(mPendingMO.getAddress(),
obtainMessage(EVENT_THREE_WAY_DIAL_L2_RESULT_CDMA));
}
}
}, m3WayCallFlashDelay);
} else {
mPendingMO = null;
Rlog.w(LOG_TAG, "exception happened on Blank Flash for 3-way call");
}
break;
default:{
throw new RuntimeException("unexpected event not handled");
}
}
}
/**
* Handle Ecm timer to be canceled or re-started
*/
private void handleEcmTimer(int action) {
mPhone.handleTimerInEmergencyCallbackMode(action);
switch(action) {
case CDMAPhone.CANCEL_ECM_TIMER: mIsEcmTimerCanceled = true; break;
case CDMAPhone.RESTART_ECM_TIMER: mIsEcmTimerCanceled = false; break;
default:
Rlog.e(LOG_TAG, "handleEcmTimer, unsupported action " + action);
}
}
/**
* Disable data call when emergency call is connected
*/
private void disableDataCallInEmergencyCall(String dialString) {
if (PhoneNumberUtils.isLocalEmergencyNumber(mPhone.getContext(), dialString)) {
if (Phone.DEBUG_PHONE) log("disableDataCallInEmergencyCall");
mIsInEmergencyCall = true;
mPhone.mDcTracker.setInternalDataEnabled(false);
}
}
/**
* Check and enable data call after an emergency call is dropped if it's
* not in ECM
*/
private void checkAndEnableDataCallAfterEmergencyCallDropped() {
if (mIsInEmergencyCall) {
mIsInEmergencyCall = false;
String inEcm=SystemProperties.get(TelephonyProperties.PROPERTY_INECM_MODE, "false");
if (Phone.DEBUG_PHONE) {
log("checkAndEnableDataCallAfterEmergencyCallDropped,inEcm=" + inEcm);
}
if (inEcm.compareTo("false") == 0) {
// Re-initiate data connection
mPhone.mDcTracker.setInternalDataEnabled(true);
}
}
}
/**
* Check the MT call to see if it's a new ring or
* a unknown connection.
*/
private Connection checkMtFindNewRinging(DriverCall dc, int i) {
Connection newRinging = null;
// it's a ringing call
if (mConnections[i].getCall() == mRingingCall) {
newRinging = mConnections[i];
if (Phone.DEBUG_PHONE) log("Notify new ring " + dc);
} else {
// Something strange happened: a call which is neither
// a ringing call nor the one we created. It could be the
// call collision result from RIL
Rlog.e(LOG_TAG,"Phantom call appeared " + dc);
// If it's a connected call, set the connect time so that
// it's non-zero. It may not be accurate, but at least
// it won't appear as a Missed Call.
if (dc.state != DriverCall.State.ALERTING
&& dc.state != DriverCall.State.DIALING) {
mConnections[i].onConnectedInOrOut();
if (dc.state == DriverCall.State.HOLDING) {
// We've transitioned into HOLDING
mConnections[i].onStartedHolding();
}
}
}
return newRinging;
}
/**
* Check if current call is in emergency call
*
* @return true if it is in emergency call
* false if it is not in emergency call
*/
boolean isInEmergencyCall() {
return mIsInEmergencyCall;
}
@Override
protected void log(String msg) {
Rlog.d(LOG_TAG, "[CdmaCallTracker] " + msg);
}
@Override
public void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
pw.println("GsmCallTracker extends:");
super.dump(fd, pw, args);
pw.println("droppedDuringPoll: length=" + mConnections.length);
for(int i=0; i < mConnections.length; i++) {
pw.printf(" mConnections[%d]=%s\n", i, mConnections[i]);
}
pw.println(" mVoiceCallEndedRegistrants=" + mVoiceCallEndedRegistrants);
pw.println(" mVoiceCallStartedRegistrants=" + mVoiceCallStartedRegistrants);
pw.println(" mCallWaitingRegistrants=" + mCallWaitingRegistrants);
pw.println("droppedDuringPoll: size=" + mDroppedDuringPoll.size());
for(int i = 0; i < mDroppedDuringPoll.size(); i++) {
pw.printf( " mDroppedDuringPoll[%d]=%s\n", i, mDroppedDuringPoll.get(i));
}
pw.println(" mRingingCall=" + mRingingCall);
pw.println(" mForegroundCall=" + mForegroundCall);
pw.println(" mBackgroundCall=" + mBackgroundCall);
pw.println(" mPendingMO=" + mPendingMO);
pw.println(" mHangupPendingMO=" + mHangupPendingMO);
pw.println(" mPendingCallInEcm=" + mPendingCallInEcm);
pw.println(" mIsInEmergencyCall=" + mIsInEmergencyCall);
pw.println(" mPhone=" + mPhone);
pw.println(" mDesiredMute=" + mDesiredMute);
pw.println(" mPendingCallClirMode=" + mPendingCallClirMode);
pw.println(" mState=" + mState);
pw.println(" mIsEcmTimerCanceled=" + mIsEcmTimerCanceled);
}
@Override
public PhoneConstants.State getState() {
return mState;
}
}
|
