| /* |
| * 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.gsm; |
| |
| import android.os.AsyncResult; |
| import android.os.Handler; |
| import android.os.Message; |
| import android.os.Registrant; |
| import android.os.RegistrantList; |
| import android.os.SystemProperties; |
| import android.telephony.DisconnectCause; |
| import android.telephony.PhoneNumberUtils; |
| import android.telephony.ServiceState; |
| import android.telephony.TelephonyManager; |
| import android.telephony.gsm.GsmCellLocation; |
| import android.util.EventLog; |
| import android.telephony.Rlog; |
| |
| import com.android.internal.telephony.Call; |
| 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.EventLogTags; |
| 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.UUSInfo; |
| import com.android.internal.telephony.gsm.CallFailCause; |
| import com.android.internal.telephony.gsm.GSMPhone; |
| import com.android.internal.telephony.gsm.GsmCall; |
| import com.android.internal.telephony.gsm.GsmConnection; |
| |
| import java.io.FileDescriptor; |
| import java.io.PrintWriter; |
| import java.util.List; |
| import java.util.ArrayList; |
| |
| /** |
| * {@hide} |
| */ |
| public final class GsmCallTracker extends CallTracker { |
| static final String LOG_TAG = "GsmCallTracker"; |
| private static final boolean REPEAT_POLLING = false; |
| |
| private static final boolean DBG_POLL = false; |
| |
| //***** Constants |
| |
| static final int MAX_CONNECTIONS = 7; // only 7 connections allowed in GSM |
| static final int MAX_CONNECTIONS_PER_CALL = 5; // only 5 connections allowed per call |
| |
| //***** Instance Variables |
| GsmConnection mConnections[] = new GsmConnection[MAX_CONNECTIONS]; |
| RegistrantList mVoiceCallEndedRegistrants = new RegistrantList(); |
| RegistrantList mVoiceCallStartedRegistrants = new RegistrantList(); |
| |
| |
| // connections dropped during last poll |
| ArrayList<GsmConnection> mDroppedDuringPoll |
| = new ArrayList<GsmConnection>(MAX_CONNECTIONS); |
| |
| GsmCall mRingingCall = new GsmCall(this); |
| // A call that is ringing or (call) waiting |
| GsmCall mForegroundCall = new GsmCall(this); |
| GsmCall mBackgroundCall = new GsmCall(this); |
| |
| GsmConnection mPendingMO; |
| boolean mHangupPendingMO; |
| |
| GSMPhone mPhone; |
| |
| boolean mDesiredMute = false; // false = mute off |
| |
| PhoneConstants.State mState = PhoneConstants.State.IDLE; |
| |
| Call.SrvccState mSrvccState = Call.SrvccState.NONE; |
| |
| |
| //***** Events |
| |
| |
| //***** Constructors |
| |
| GsmCallTracker (GSMPhone phone) { |
| this.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); |
| } |
| |
| public void dispose() { |
| Rlog.d(LOG_TAG, "GsmCallTracker dispose"); |
| //Unregister for all events |
| mCi.unregisterForCallStateChanged(this); |
| mCi.unregisterForOn(this); |
| mCi.unregisterForNotAvailable(this); |
| |
| |
| clearDisconnected(); |
| } |
| |
| @Override |
| protected void finalize() { |
| Rlog.d(LOG_TAG, "GsmCallTracker 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); |
| } |
| |
| @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); |
| } |
| |
| private void |
| fakeHoldForegroundBeforeDial() { |
| List<Connection> connCopy; |
| |
| // We need to make a copy here, since fakeHoldBeforeDial() |
| // modifies the lists, and we don't want to reverse the order |
| connCopy = (List<Connection>) mForegroundCall.mConnections.clone(); |
| |
| for (int i = 0, s = connCopy.size() ; i < s ; i++) { |
| GsmConnection conn = (GsmConnection)connCopy.get(i); |
| |
| conn.fakeHoldBeforeDial(); |
| } |
| } |
| |
| /** |
| * clirMode is one of the CLIR_ constants |
| */ |
| synchronized Connection |
| dial (String dialString, int clirMode, UUSInfo uusInfo) throws CallStateException { |
| // note that this triggers call state changed notif |
| clearDisconnected(); |
| |
| if (!canDial()) { |
| throw new CallStateException("cannot dial in current state"); |
| } |
| |
| // 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() == GsmCall.State.ACTIVE) { |
| // this will probably be done by the radio anyway |
| // but the dial might fail before this happens |
| // and we need to make sure the foreground call is clear |
| // for the newly dialed connection |
| switchWaitingOrHoldingAndActive(); |
| |
| // Fake local state so that |
| // a) foregroundCall is empty for the newly dialed connection |
| // b) hasNonHangupStateChanged remains false in the |
| // next poll, so that we don't clear a failed dialing call |
| fakeHoldForegroundBeforeDial(); |
| } |
| |
| if (mForegroundCall.getState() != GsmCall.State.IDLE) { |
| //we should have failed in !canDial() above before we get here |
| throw new CallStateException("cannot dial in current state"); |
| } |
| |
| mPendingMO = new GsmConnection(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); |
| |
| mCi.dial(mPendingMO.getAddress(), clirMode, uusInfo, obtainCompleteMessage()); |
| } |
| |
| updatePhoneState(); |
| mPhone.notifyPreciseCallStateChanged(); |
| |
| return mPendingMO; |
| } |
| |
| Connection |
| dial(String dialString) throws CallStateException { |
| return dial(dialString, CommandsInterface.CLIR_DEFAULT, null); |
| } |
| |
| Connection |
| dial(String dialString, UUSInfo uusInfo) throws CallStateException { |
| return dial(dialString, CommandsInterface.CLIR_DEFAULT, uusInfo); |
| } |
| |
| Connection |
| dial(String dialString, int clirMode) throws CallStateException { |
| return dial(dialString, clirMode, null); |
| } |
| |
| void |
| acceptCall () throws CallStateException { |
| // FIXME if SWITCH fails, should retry with ANSWER |
| // in case the active/holding call disappeared and this |
| // is no longer call waiting |
| |
| if (mRingingCall.getState() == GsmCall.State.INCOMING) { |
| Rlog.i("phone", "acceptCall: incoming..."); |
| // Always unmute when answering a new call |
| setMute(false); |
| mCi.acceptCall(obtainCompleteMessage()); |
| } else if (mRingingCall.getState() == GsmCall.State.WAITING) { |
| setMute(false); |
| 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() == GsmCall.State.INCOMING) { |
| throw new CallStateException("cannot be in the incoming state"); |
| } else { |
| mCi.switchWaitingOrHoldingAndActive( |
| obtainCompleteMessage(EVENT_SWITCH_RESULT)); |
| } |
| } |
| |
| void |
| conference() { |
| mCi.conference(obtainCompleteMessage(EVENT_CONFERENCE_RESULT)); |
| } |
| |
| void |
| explicitCallTransfer() { |
| mCi.explicitCallTransfer(obtainCompleteMessage(EVENT_ECT_RESULT)); |
| } |
| |
| void |
| clearDisconnected() { |
| internalClearDisconnected(); |
| |
| updatePhoneState(); |
| mPhone.notifyPreciseCallStateChanged(); |
| } |
| |
| boolean |
| canConference() { |
| return mForegroundCall.getState() == GsmCall.State.ACTIVE |
| && mBackgroundCall.getState() == GsmCall.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() |
| || !mBackgroundCall.getState().isAlive()); |
| |
| return ret; |
| } |
| |
| boolean |
| canTransfer() { |
| return (mForegroundCall.getState() == GsmCall.State.ACTIVE |
| || mForegroundCall.getState() == GsmCall.State.ALERTING |
| || mForegroundCall.getState() == GsmCall.State.DIALING) |
| && mBackgroundCall.getState() == GsmCall.State.HOLDING; |
| } |
| |
| //***** 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,"GsmCallTracker.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 { |
| 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 (mState != oldState) { |
| mPhone.notifyPhoneStateChanged(); |
| } |
| } |
| |
| @Override |
| protected synchronized 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 |
| 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++) { |
| GsmConnection 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; |
| 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 { |
| mConnections[i] = new GsmConnection(mPhone.getContext(), dc, this, i); |
| |
| // it's a ringing call |
| if (mConnections[i].getCall() == mRingingCall) { |
| newRinging = mConnections[i]; |
| } else if (mHandoverConnection != null) { |
| // Single Radio Voice Call Continuity (SRVCC) completed |
| mPhone.migrateFrom((PhoneBase) mPhone.getImsPhone()); |
| mConnections[i].migrateFrom(mHandoverConnection); |
| mPhone.notifyHandoverStateChanged(mConnections[i]); |
| mHandoverConnection = null; |
| } else { |
| // Something strange happened: a call appeared |
| // which is neither a ringing call or one we created. |
| // Either we've crashed and re-attached to an existing |
| // call, or something else (eg, SIM) initiated the call. |
| |
| Rlog.i(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(); |
| } |
| } |
| |
| unknownConnectionAppeared = true; |
| } |
| } |
| hasNonHangupStateChanged = true; |
| } else if (conn != null && dc == null) { |
| // Connection missing in CLCC response that we were |
| // tracking. |
| mDroppedDuringPoll.add(conn); |
| // Dropped connections are removed from the CallTracker |
| // list but kept in the GsmCall list |
| mConnections[i] = null; |
| } else if (conn != null && dc != null && !conn.compareTo(dc)) { |
| // Connection in CLCC response does not match what |
| // we were tracking. Assume dropped call and new call |
| |
| mDroppedDuringPoll.add(conn); |
| mConnections[i] = new GsmConnection (mPhone.getContext(), dc, this, i); |
| |
| if (mConnections[i].getCall() == mRingingCall) { |
| newRinging = mConnections[i]; |
| } // else something strange happened |
| hasNonHangupStateChanged = true; |
| } else if (conn != null && dc != null) { /* implicit conn.compareTo(dc) */ |
| 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 (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--) { |
| GsmConnection 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); |
| } |
| } |
| |
| // 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(); |
| } |
| |
| if (hasNonHangupStateChanged || newRinging != null || hasAnyCallDisconnected) { |
| mPhone.notifyPreciseCallStateChanged(); |
| } |
| |
| //dumpState(); |
| } |
| |
| private void |
| handleRadioNotAvailable() { |
| // handlePollCalls will clear out its |
| // call list when it gets the CommandException |
| // error result from this |
| pollCallsWhenSafe(); |
| } |
| |
| private void |
| dumpState() { |
| List l; |
| |
| Rlog.i(LOG_TAG,"Phone State:" + mState); |
| |
| Rlog.i(LOG_TAG,"Ringing call: " + mRingingCall.toString()); |
| |
| l = mRingingCall.getConnections(); |
| for (int i = 0, s = l.size(); i < s; i++) { |
| Rlog.i(LOG_TAG,l.get(i).toString()); |
| } |
| |
| Rlog.i(LOG_TAG,"Foreground call: " + mForegroundCall.toString()); |
| |
| l = mForegroundCall.getConnections(); |
| for (int i = 0, s = l.size(); i < s; i++) { |
| Rlog.i(LOG_TAG,l.get(i).toString()); |
| } |
| |
| Rlog.i(LOG_TAG,"Background call: " + mBackgroundCall.toString()); |
| |
| l = mBackgroundCall.getConnections(); |
| for (int i = 0, s = l.size(); i < s; i++) { |
| Rlog.i(LOG_TAG,l.get(i).toString()); |
| } |
| |
| } |
| |
| //***** Called from GsmConnection |
| |
| /*package*/ void |
| hangup (GsmConnection conn) throws CallStateException { |
| if (conn.mOwner != this) { |
| throw new CallStateException ("GsmConnection " + conn |
| + "does not belong to GsmCallTracker " + 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 { |
| try { |
| mCi.hangupConnection (conn.getGSMIndex(), obtainCompleteMessage()); |
| } catch (CallStateException ex) { |
| // Ignore "connection not found" |
| // Call may have hung up already |
| Rlog.w(LOG_TAG,"GsmCallTracker WARN: hangup() on absent connection " |
| + conn); |
| } |
| } |
| |
| conn.onHangupLocal(); |
| } |
| |
| /*package*/ void |
| separate (GsmConnection conn) throws CallStateException { |
| if (conn.mOwner != this) { |
| throw new CallStateException ("GsmConnection " + conn |
| + "does not belong to GsmCallTracker " + this); |
| } |
| try { |
| mCi.separateConnection (conn.getGSMIndex(), |
| obtainCompleteMessage(EVENT_SEPARATE_RESULT)); |
| } catch (CallStateException ex) { |
| // Ignore "connection not found" |
| // Call may have hung up already |
| Rlog.w(LOG_TAG,"GsmCallTracker WARN: separate() on absent connection " |
| + conn); |
| } |
| } |
| |
| //***** Called from GSMPhone |
| |
| /*package*/ void |
| setMute(boolean mute) { |
| mDesiredMute = mute; |
| mCi.setMute(mDesiredMute, null); |
| } |
| |
| /*package*/ boolean |
| getMute() { |
| return mDesiredMute; |
| } |
| |
| |
| //***** Called from GsmCall |
| |
| /* package */ void |
| hangup (GsmCall 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((GsmConnection)(call.getConnections().get(0))); |
| } else if (mRingingCall.isRinging()) { |
| // Do not auto-answer ringing on CHUP, instead just end active calls |
| log("hangup all conns in active/background call, without affecting ringing call"); |
| hangupAllConnections(call); |
| } 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 ("GsmCall " + call + |
| "does not belong to GsmCallTracker " + 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(GsmCall call, int index) |
| throws CallStateException { |
| int count = call.mConnections.size(); |
| for (int i = 0; i < count; i++) { |
| GsmConnection cn = (GsmConnection)call.mConnections.get(i); |
| if (cn.getGSMIndex() == index) { |
| mCi.hangupConnection(index, obtainCompleteMessage()); |
| return; |
| } |
| } |
| |
| throw new CallStateException("no gsm index found"); |
| } |
| |
| void hangupAllConnections(GsmCall call) { |
| try { |
| int count = call.mConnections.size(); |
| for (int i = 0; i < count; i++) { |
| GsmConnection cn = (GsmConnection)call.mConnections.get(i); |
| mCi.hangupConnection(cn.getGSMIndex(), obtainCompleteMessage()); |
| } |
| } catch (CallStateException ex) { |
| Rlog.e(LOG_TAG, "hangupConnectionByIndex caught " + ex); |
| } |
| } |
| |
| /* package */ |
| GsmConnection getConnectionByIndex(GsmCall call, int index) |
| throws CallStateException { |
| int count = call.mConnections.size(); |
| for (int i = 0; i < count; i++) { |
| GsmConnection cn = (GsmConnection)call.mConnections.get(i); |
| if (cn.getGSMIndex() == index) { |
| return cn; |
| } |
| } |
| |
| return null; |
| } |
| |
| private Phone.SuppService getFailedService(int what) { |
| switch (what) { |
| case EVENT_SWITCH_RESULT: |
| return Phone.SuppService.SWITCH; |
| case EVENT_CONFERENCE_RESULT: |
| return Phone.SuppService.CONFERENCE; |
| case EVENT_SEPARATE_RESULT: |
| return Phone.SuppService.SEPARATE; |
| case EVENT_ECT_RESULT: |
| return Phone.SuppService.TRANSFER; |
| } |
| return Phone.SuppService.UNKNOWN; |
| } |
| |
| //****** Overridden from Handler |
| |
| @Override |
| public void |
| handleMessage (Message msg) { |
| AsyncResult ar; |
| |
| if (!mPhone.mIsTheCurrentActivePhone) { |
| Rlog.e(LOG_TAG, "Received message " + msg + |
| "[" + msg.what + "] while being destroyed. Ignoring."); |
| return; |
| } |
| switch (msg.what) { |
| case EVENT_POLL_CALLS_RESULT: |
| 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: |
| ar = (AsyncResult)msg.obj; |
| operationComplete(); |
| break; |
| |
| case EVENT_SWITCH_RESULT: |
| case EVENT_CONFERENCE_RESULT: |
| case EVENT_SEPARATE_RESULT: |
| case EVENT_ECT_RESULT: |
| ar = (AsyncResult)msg.obj; |
| if (ar.exception != null) { |
| mPhone.notifySuppServiceFailed(getFailedService(msg.what)); |
| } |
| operationComplete(); |
| 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]; |
| } |
| // Log the causeCode if its not normal |
| if (causeCode == CallFailCause.NO_CIRCUIT_AVAIL || |
| causeCode == CallFailCause.TEMPORARY_FAILURE || |
| causeCode == CallFailCause.SWITCHING_CONGESTION || |
| causeCode == CallFailCause.CHANNEL_NOT_AVAIL || |
| causeCode == CallFailCause.QOS_NOT_AVAIL || |
| causeCode == CallFailCause.BEARER_NOT_AVAIL || |
| causeCode == CallFailCause.ERROR_UNSPECIFIED) { |
| GsmCellLocation loc = ((GsmCellLocation)mPhone.getCellLocation()); |
| EventLog.writeEvent(EventLogTags.CALL_DROP, |
| causeCode, loc != null ? loc.getCid() : -1, |
| TelephonyManager.getDefault().getNetworkType()); |
| } |
| |
| for (int i = 0, s = mDroppedDuringPoll.size() |
| ; i < s ; i++ |
| ) { |
| GsmConnection 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; |
| } |
| } |
| |
| @Override |
| protected void log(String msg) { |
| Rlog.d(LOG_TAG, "[GsmCallTracker] " + msg); |
| } |
| |
| @Override |
| public void dump(FileDescriptor fd, PrintWriter pw, String[] args) { |
| pw.println("GsmCallTracker extends:"); |
| super.dump(fd, pw, args); |
| pw.println("mConnections: 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(" mDroppedDuringPoll: 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(" mPhone=" + mPhone); |
| pw.println(" mDesiredMute=" + mDesiredMute); |
| pw.println(" mState=" + mState); |
| } |
| } |
