1276 lines
44 KiB
Java
1276 lines
44 KiB
Java
/*
|
|
* Copyright (C) 2015 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;
|
|
import android.compat.annotation.UnsupportedAppUsage;
|
|
import android.content.Context;
|
|
import android.os.AsyncResult;
|
|
import android.os.Build;
|
|
import android.os.Handler;
|
|
import android.os.Looper;
|
|
import android.os.Message;
|
|
import android.os.PersistableBundle;
|
|
import android.os.PowerManager;
|
|
import android.os.Registrant;
|
|
import android.os.SystemClock;
|
|
import android.telephony.CarrierConfigManager;
|
|
import android.telephony.DisconnectCause;
|
|
import android.telephony.PhoneNumberUtils;
|
|
import android.telephony.ServiceState;
|
|
import android.text.TextUtils;
|
|
|
|
import com.android.internal.telephony.PhoneInternalInterface.DialArgs;
|
|
import com.android.internal.telephony.cdma.CdmaCallWaitingNotification;
|
|
import com.android.internal.telephony.cdma.CdmaSubscriptionSourceManager;
|
|
import com.android.internal.telephony.emergency.EmergencyNumberTracker;
|
|
import com.android.internal.telephony.metrics.TelephonyMetrics;
|
|
import com.android.internal.telephony.uicc.IccCardApplicationStatus.AppState;
|
|
import com.android.internal.telephony.uicc.UiccCardApplication;
|
|
import com.android.telephony.Rlog;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.Collections;
|
|
|
|
/**
|
|
* {@hide}
|
|
*/
|
|
public class GsmCdmaConnection extends Connection {
|
|
private static final String LOG_TAG = "GsmCdmaConnection";
|
|
private static final boolean DBG = true;
|
|
private static final boolean VDBG = false;
|
|
|
|
public static final String OTASP_NUMBER = "*22899";
|
|
|
|
//***** Instance Variables
|
|
|
|
@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.R, trackingBug = 170729553)
|
|
GsmCdmaCallTracker mOwner;
|
|
GsmCdmaCall mParent;
|
|
|
|
boolean mDisconnected;
|
|
|
|
@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.R, trackingBug = 170729553)
|
|
int mIndex; // index in GsmCdmaCallTracker.connections[], -1 if unassigned
|
|
// The GsmCdma index is 1 + this
|
|
|
|
/*
|
|
* These time/timespan values are based on System.currentTimeMillis(),
|
|
* i.e., "wall clock" time.
|
|
*/
|
|
long mDisconnectTime;
|
|
|
|
UUSInfo mUusInfo;
|
|
int mPreciseCause = 0;
|
|
String mVendorCause;
|
|
|
|
Connection mOrigConnection;
|
|
|
|
Handler mHandler;
|
|
|
|
private PowerManager.WakeLock mPartialWakeLock;
|
|
|
|
// The cached delay to be used between DTMF tones fetched from carrier config.
|
|
private int mDtmfToneDelay = 0;
|
|
|
|
private TelephonyMetrics mMetrics = TelephonyMetrics.getInstance();
|
|
|
|
//***** Event Constants
|
|
static final int EVENT_DTMF_DONE = 1;
|
|
static final int EVENT_PAUSE_DONE = 2;
|
|
static final int EVENT_NEXT_POST_DIAL = 3;
|
|
static final int EVENT_WAKE_LOCK_TIMEOUT = 4;
|
|
static final int EVENT_DTMF_DELAY_DONE = 5;
|
|
|
|
//***** Constants
|
|
static final int PAUSE_DELAY_MILLIS_GSM = 3 * 1000;
|
|
static final int PAUSE_DELAY_MILLIS_CDMA = 2 * 1000;
|
|
static final int WAKE_LOCK_TIMEOUT_MILLIS = 60 * 1000;
|
|
|
|
//***** Inner Classes
|
|
|
|
class MyHandler extends Handler {
|
|
MyHandler(Looper l) {super(l);}
|
|
|
|
@Override
|
|
public void
|
|
handleMessage(Message msg) {
|
|
|
|
switch (msg.what) {
|
|
case EVENT_NEXT_POST_DIAL:
|
|
case EVENT_DTMF_DELAY_DONE:
|
|
case EVENT_PAUSE_DONE:
|
|
processNextPostDialChar();
|
|
break;
|
|
case EVENT_WAKE_LOCK_TIMEOUT:
|
|
releaseWakeLock();
|
|
break;
|
|
case EVENT_DTMF_DONE:
|
|
// We may need to add a delay specified by carrier between DTMF tones that are
|
|
// sent out.
|
|
mHandler.sendMessageDelayed(mHandler.obtainMessage(EVENT_DTMF_DELAY_DONE),
|
|
mDtmfToneDelay);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
//***** Constructors
|
|
|
|
/** This is probably an MT call that we first saw in a CLCC response or a hand over. */
|
|
public GsmCdmaConnection (GsmCdmaPhone phone, DriverCall dc, GsmCdmaCallTracker ct, int index) {
|
|
super(phone.getPhoneType());
|
|
createWakeLock(phone.getContext());
|
|
acquireWakeLock();
|
|
|
|
mOwner = ct;
|
|
mHandler = new MyHandler(mOwner.getLooper());
|
|
|
|
mAddress = dc.number;
|
|
setEmergencyCallInfo(mOwner);
|
|
|
|
String forwardedNumber = TextUtils.isEmpty(dc.forwardedNumber) ? null : dc.forwardedNumber;
|
|
Rlog.i(LOG_TAG, "create, forwardedNumber=" + Rlog.pii(LOG_TAG, forwardedNumber));
|
|
mForwardedNumber = forwardedNumber == null ? null :
|
|
new ArrayList<>(Collections.singletonList(dc.forwardedNumber));
|
|
mIsIncoming = dc.isMT;
|
|
mCreateTime = System.currentTimeMillis();
|
|
mCnapName = dc.name;
|
|
mCnapNamePresentation = dc.namePresentation;
|
|
mNumberPresentation = dc.numberPresentation;
|
|
mUusInfo = dc.uusInfo;
|
|
|
|
mIndex = index;
|
|
|
|
mParent = parentFromDCState(dc.state);
|
|
mParent.attach(this, dc);
|
|
|
|
fetchDtmfToneDelay(phone);
|
|
|
|
setAudioQuality(getAudioQualityFromDC(dc.audioQuality));
|
|
|
|
setCallRadioTech(mOwner.getPhone().getCsCallRadioTech());
|
|
}
|
|
|
|
/** This is an MO call, created when dialing */
|
|
public GsmCdmaConnection (GsmCdmaPhone phone, String dialString, GsmCdmaCallTracker ct,
|
|
GsmCdmaCall parent, DialArgs dialArgs) {
|
|
super(phone.getPhoneType());
|
|
createWakeLock(phone.getContext());
|
|
acquireWakeLock();
|
|
|
|
mOwner = ct;
|
|
mHandler = new MyHandler(mOwner.getLooper());
|
|
|
|
mDialString = dialString;
|
|
if (!isPhoneTypeGsm()) {
|
|
Rlog.d(LOG_TAG, "[GsmCdmaConn] GsmCdmaConnection: dialString=" +
|
|
maskDialString(dialString));
|
|
dialString = formatDialString(dialString);
|
|
Rlog.d(LOG_TAG,
|
|
"[GsmCdmaConn] GsmCdmaConnection:formated dialString=" +
|
|
maskDialString(dialString));
|
|
}
|
|
|
|
mAddress = PhoneNumberUtils.extractNetworkPortionAlt(dialString);
|
|
if (dialArgs.isEmergency) {
|
|
setEmergencyCallInfo(mOwner);
|
|
|
|
// There was no emergency number info found for this call, however it is
|
|
// still marked as an emergency number. This may happen if it was a redialed
|
|
// non-detectable emergency call from IMS.
|
|
if (getEmergencyNumberInfo() == null) {
|
|
setNonDetectableEmergencyCallInfo(dialArgs.eccCategory);
|
|
}
|
|
}
|
|
|
|
mPostDialString = PhoneNumberUtils.extractPostDialPortion(dialString);
|
|
|
|
mIndex = -1;
|
|
|
|
mIsIncoming = false;
|
|
mCnapName = null;
|
|
mCnapNamePresentation = PhoneConstants.PRESENTATION_ALLOWED;
|
|
mNumberPresentation = PhoneConstants.PRESENTATION_ALLOWED;
|
|
mCreateTime = System.currentTimeMillis();
|
|
|
|
if (parent != null) {
|
|
mParent = parent;
|
|
if (isPhoneTypeGsm()) {
|
|
parent.attachFake(this, GsmCdmaCall.State.DIALING);
|
|
} else {
|
|
//for the three way call case, not change parent state
|
|
if (parent.mState == GsmCdmaCall.State.ACTIVE) {
|
|
parent.attachFake(this, GsmCdmaCall.State.ACTIVE);
|
|
} else {
|
|
parent.attachFake(this, GsmCdmaCall.State.DIALING);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
fetchDtmfToneDelay(phone);
|
|
|
|
setCallRadioTech(mOwner.getPhone().getCsCallRadioTech());
|
|
}
|
|
|
|
//CDMA
|
|
/** This is a Call waiting call*/
|
|
public GsmCdmaConnection(Context context, CdmaCallWaitingNotification cw, GsmCdmaCallTracker ct,
|
|
GsmCdmaCall parent) {
|
|
super(parent.getPhone().getPhoneType());
|
|
createWakeLock(context);
|
|
acquireWakeLock();
|
|
|
|
mOwner = ct;
|
|
mHandler = new MyHandler(mOwner.getLooper());
|
|
mAddress = cw.number;
|
|
mNumberPresentation = cw.numberPresentation;
|
|
mCnapName = cw.name;
|
|
mCnapNamePresentation = cw.namePresentation;
|
|
mIndex = -1;
|
|
mIsIncoming = true;
|
|
mCreateTime = System.currentTimeMillis();
|
|
mConnectTime = 0;
|
|
mParent = parent;
|
|
parent.attachFake(this, GsmCdmaCall.State.WAITING);
|
|
|
|
setCallRadioTech(mOwner.getPhone().getCsCallRadioTech());
|
|
}
|
|
|
|
|
|
public void dispose() {
|
|
clearPostDialListeners();
|
|
if (mParent != null) {
|
|
mParent.detach(this);
|
|
}
|
|
releaseAllWakeLocks();
|
|
}
|
|
|
|
static boolean equalsHandlesNulls(Object a, Object b) {
|
|
return (a == null) ? (b == null) : a.equals (b);
|
|
}
|
|
|
|
static boolean
|
|
equalsBaseDialString (String a, String b) {
|
|
return (a == null) ? (b == null) : (b != null && a.startsWith (b));
|
|
}
|
|
|
|
//CDMA
|
|
/**
|
|
* format original dial string
|
|
* 1) convert international dialing prefix "+" to
|
|
* string specified per region
|
|
*
|
|
* 2) handle corner cases for PAUSE/WAIT dialing:
|
|
*
|
|
* If PAUSE/WAIT sequence at the end, ignore them.
|
|
*
|
|
* If consecutive PAUSE/WAIT sequence in the middle of the string,
|
|
* and if there is any WAIT in PAUSE/WAIT sequence, treat them like WAIT.
|
|
*/
|
|
@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.R, trackingBug = 170729553)
|
|
public static String formatDialString(String phoneNumber) {
|
|
/**
|
|
* TODO(cleanup): This function should move to PhoneNumberUtils, and
|
|
* tests should be added.
|
|
*/
|
|
|
|
if (phoneNumber == null) {
|
|
return null;
|
|
}
|
|
int length = phoneNumber.length();
|
|
StringBuilder ret = new StringBuilder();
|
|
char c;
|
|
int currIndex = 0;
|
|
|
|
while (currIndex < length) {
|
|
c = phoneNumber.charAt(currIndex);
|
|
if (isPause(c) || isWait(c)) {
|
|
if (currIndex < length - 1) {
|
|
// if PW not at the end
|
|
int nextIndex = findNextPCharOrNonPOrNonWCharIndex(phoneNumber, currIndex);
|
|
// If there is non PW char following PW sequence
|
|
if (nextIndex < length) {
|
|
char pC = findPOrWCharToAppend(phoneNumber, currIndex, nextIndex);
|
|
ret.append(pC);
|
|
// If PW char sequence has more than 2 PW characters,
|
|
// skip to the last PW character since the sequence already be
|
|
// converted to WAIT character
|
|
if (nextIndex > (currIndex + 1)) {
|
|
currIndex = nextIndex - 1;
|
|
}
|
|
} else if (nextIndex == length) {
|
|
// It means PW characters at the end, ignore
|
|
currIndex = length - 1;
|
|
}
|
|
}
|
|
} else {
|
|
ret.append(c);
|
|
}
|
|
currIndex++;
|
|
}
|
|
return PhoneNumberUtils.cdmaCheckAndProcessPlusCode(ret.toString());
|
|
}
|
|
|
|
/*package*/ boolean
|
|
compareTo(DriverCall c) {
|
|
// On mobile originated (MO) calls, the phone number may have changed
|
|
// due to a SIM Toolkit call control modification.
|
|
//
|
|
// We assume we know when MO calls are created (since we created them)
|
|
// and therefore don't need to compare the phone number anyway.
|
|
if (! (mIsIncoming || c.isMT)) return true;
|
|
|
|
// A new call appearing by SRVCC may have invalid number
|
|
// if IMS service is not tightly coupled with cellular modem stack.
|
|
// Thus we prefer the preexisting handover connection instance.
|
|
if (isPhoneTypeGsm() && mOrigConnection != null) return true;
|
|
|
|
// ... but we can compare phone numbers on MT calls, and we have
|
|
// no control over when they begin, so we might as well
|
|
|
|
String cAddress = PhoneNumberUtils.stringFromStringAndTOA(c.number, c.TOA);
|
|
return mIsIncoming == c.isMT && equalsHandlesNulls(mAddress, cAddress);
|
|
}
|
|
|
|
@Override
|
|
public String getOrigDialString(){
|
|
return mDialString;
|
|
}
|
|
|
|
@Override
|
|
public GsmCdmaCall getCall() {
|
|
return mParent;
|
|
}
|
|
|
|
@Override
|
|
public long getDisconnectTime() {
|
|
return mDisconnectTime;
|
|
}
|
|
|
|
@Override
|
|
public long getHoldDurationMillis() {
|
|
if (getState() != GsmCdmaCall.State.HOLDING) {
|
|
// If not holding, return 0
|
|
return 0;
|
|
} else {
|
|
return SystemClock.elapsedRealtime() - mHoldingStartTime;
|
|
}
|
|
}
|
|
|
|
@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.R, trackingBug = 170729553)
|
|
@Override
|
|
public GsmCdmaCall.State getState() {
|
|
if (mDisconnected) {
|
|
return GsmCdmaCall.State.DISCONNECTED;
|
|
} else {
|
|
return super.getState();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void hangup() throws CallStateException {
|
|
if (!mDisconnected) {
|
|
mOwner.hangup(this);
|
|
} else {
|
|
throw new CallStateException ("disconnected");
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void deflect(String number) throws CallStateException {
|
|
// Deflect is not supported.
|
|
throw new CallStateException ("deflect is not supported for CS");
|
|
}
|
|
|
|
@Override
|
|
public void transfer(String number, boolean isConfirmationRequired) throws CallStateException {
|
|
// Transfer is not supported.
|
|
throw new CallStateException("Transfer is not supported for CS");
|
|
}
|
|
|
|
@Override
|
|
public void consultativeTransfer(Connection other) throws CallStateException {
|
|
// Transfer is not supported.
|
|
throw new CallStateException("Transfer is not supported for CS");
|
|
}
|
|
|
|
@Override
|
|
public void separate() throws CallStateException {
|
|
if (!mDisconnected) {
|
|
mOwner.separate(this);
|
|
} else {
|
|
throw new CallStateException ("disconnected");
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void proceedAfterWaitChar() {
|
|
if (mPostDialState != PostDialState.WAIT) {
|
|
Rlog.w(LOG_TAG, "GsmCdmaConnection.proceedAfterWaitChar(): Expected "
|
|
+ "getPostDialState() to be WAIT but was " + mPostDialState);
|
|
return;
|
|
}
|
|
|
|
setPostDialState(PostDialState.STARTED);
|
|
|
|
processNextPostDialChar();
|
|
}
|
|
|
|
@Override
|
|
public void proceedAfterWildChar(String str) {
|
|
if (mPostDialState != PostDialState.WILD) {
|
|
Rlog.w(LOG_TAG, "GsmCdmaConnection.proceedAfterWaitChar(): Expected "
|
|
+ "getPostDialState() to be WILD but was " + mPostDialState);
|
|
return;
|
|
}
|
|
|
|
setPostDialState(PostDialState.STARTED);
|
|
|
|
// make a new postDialString, with the wild char replacement string
|
|
// at the beginning, followed by the remaining postDialString.
|
|
|
|
StringBuilder buf = new StringBuilder(str);
|
|
buf.append(mPostDialString.substring(mNextPostDialChar));
|
|
mPostDialString = buf.toString();
|
|
mNextPostDialChar = 0;
|
|
if (Phone.DEBUG_PHONE) {
|
|
log("proceedAfterWildChar: new postDialString is " +
|
|
mPostDialString);
|
|
}
|
|
|
|
processNextPostDialChar();
|
|
}
|
|
|
|
@Override
|
|
public void cancelPostDial() {
|
|
setPostDialState(PostDialState.CANCELLED);
|
|
}
|
|
|
|
/**
|
|
* Called when this Connection is being hung up locally (eg, user pressed "end")
|
|
* Note that at this point, the hangup request has been dispatched to the radio
|
|
* but no response has yet been received so update() has not yet been called
|
|
*/
|
|
void
|
|
onHangupLocal() {
|
|
mCause = DisconnectCause.LOCAL;
|
|
mPreciseCause = 0;
|
|
mVendorCause = null;
|
|
}
|
|
|
|
/**
|
|
* Maps RIL call disconnect code to {@link DisconnectCause}.
|
|
* @param causeCode RIL disconnect code
|
|
* @return the corresponding value from {@link DisconnectCause}
|
|
*/
|
|
@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.R, trackingBug = 170729553)
|
|
public int disconnectCauseFromCode(int causeCode) {
|
|
/**
|
|
* See 22.001 Annex F.4 for mapping of cause codes
|
|
* to local tones
|
|
*/
|
|
|
|
switch (causeCode) {
|
|
case CallFailCause.USER_BUSY:
|
|
return DisconnectCause.BUSY;
|
|
|
|
case CallFailCause.NO_CIRCUIT_AVAIL:
|
|
case CallFailCause.TEMPORARY_FAILURE:
|
|
case CallFailCause.SWITCHING_CONGESTION:
|
|
case CallFailCause.CHANNEL_NOT_AVAIL:
|
|
case CallFailCause.QOS_NOT_AVAIL:
|
|
case CallFailCause.BEARER_NOT_AVAIL:
|
|
return DisconnectCause.CONGESTION;
|
|
|
|
case CallFailCause.EMERGENCY_TEMP_FAILURE:
|
|
return DisconnectCause.EMERGENCY_TEMP_FAILURE;
|
|
case CallFailCause.EMERGENCY_PERM_FAILURE:
|
|
return DisconnectCause.EMERGENCY_PERM_FAILURE;
|
|
|
|
case CallFailCause.ACM_LIMIT_EXCEEDED:
|
|
return DisconnectCause.LIMIT_EXCEEDED;
|
|
|
|
case CallFailCause.OPERATOR_DETERMINED_BARRING:
|
|
case CallFailCause.CALL_BARRED:
|
|
return DisconnectCause.CALL_BARRED;
|
|
|
|
case CallFailCause.FDN_BLOCKED:
|
|
return DisconnectCause.FDN_BLOCKED;
|
|
|
|
case CallFailCause.IMEI_NOT_ACCEPTED:
|
|
return DisconnectCause.IMEI_NOT_ACCEPTED;
|
|
|
|
case CallFailCause.UNOBTAINABLE_NUMBER:
|
|
return DisconnectCause.UNOBTAINABLE_NUMBER;
|
|
|
|
case CallFailCause.DIAL_MODIFIED_TO_USSD:
|
|
return DisconnectCause.DIAL_MODIFIED_TO_USSD;
|
|
|
|
case CallFailCause.DIAL_MODIFIED_TO_SS:
|
|
return DisconnectCause.DIAL_MODIFIED_TO_SS;
|
|
|
|
case CallFailCause.DIAL_MODIFIED_TO_DIAL:
|
|
return DisconnectCause.DIAL_MODIFIED_TO_DIAL;
|
|
|
|
case CallFailCause.CDMA_LOCKED_UNTIL_POWER_CYCLE:
|
|
return DisconnectCause.CDMA_LOCKED_UNTIL_POWER_CYCLE;
|
|
|
|
case CallFailCause.CDMA_DROP:
|
|
return DisconnectCause.CDMA_DROP;
|
|
|
|
case CallFailCause.CDMA_INTERCEPT:
|
|
return DisconnectCause.CDMA_INTERCEPT;
|
|
|
|
case CallFailCause.CDMA_REORDER:
|
|
return DisconnectCause.CDMA_REORDER;
|
|
|
|
case CallFailCause.CDMA_SO_REJECT:
|
|
return DisconnectCause.CDMA_SO_REJECT;
|
|
|
|
case CallFailCause.CDMA_RETRY_ORDER:
|
|
return DisconnectCause.CDMA_RETRY_ORDER;
|
|
|
|
case CallFailCause.CDMA_ACCESS_FAILURE:
|
|
return DisconnectCause.CDMA_ACCESS_FAILURE;
|
|
|
|
case CallFailCause.CDMA_PREEMPTED:
|
|
return DisconnectCause.CDMA_PREEMPTED;
|
|
|
|
case CallFailCause.CDMA_NOT_EMERGENCY:
|
|
return DisconnectCause.CDMA_NOT_EMERGENCY;
|
|
|
|
case CallFailCause.CDMA_ACCESS_BLOCKED:
|
|
return DisconnectCause.CDMA_ACCESS_BLOCKED;
|
|
|
|
case CallFailCause.NORMAL_UNSPECIFIED:
|
|
return DisconnectCause.NORMAL_UNSPECIFIED;
|
|
|
|
case CallFailCause.USER_ALERTING_NO_ANSWER:
|
|
return DisconnectCause.TIMED_OUT;
|
|
|
|
case CallFailCause.RADIO_OFF:
|
|
return DisconnectCause.POWER_OFF;
|
|
|
|
case CallFailCause.NO_VALID_SIM:
|
|
return DisconnectCause.ICC_ERROR;
|
|
|
|
case CallFailCause.LOCAL_NETWORK_NO_SERVICE:
|
|
// fallthrough
|
|
case CallFailCause.LOCAL_SERVICE_UNAVAILABLE:
|
|
return DisconnectCause.OUT_OF_SERVICE;
|
|
|
|
case CallFailCause.ACCESS_CLASS_BLOCKED:
|
|
case CallFailCause.ERROR_UNSPECIFIED:
|
|
case CallFailCause.NORMAL_CLEARING:
|
|
default:
|
|
GsmCdmaPhone phone = mOwner.getPhone();
|
|
int serviceState = phone.getServiceState().getState();
|
|
UiccCardApplication cardApp = phone.getUiccCardApplication();
|
|
AppState uiccAppState = (cardApp != null) ? cardApp.getState() :
|
|
AppState.APPSTATE_UNKNOWN;
|
|
if (serviceState == ServiceState.STATE_POWER_OFF) {
|
|
return DisconnectCause.POWER_OFF;
|
|
}
|
|
if (!isEmergencyCall()) {
|
|
// Only send OUT_OF_SERVICE if it is not an emergency call. We can still
|
|
// technically be in STATE_OUT_OF_SERVICE or STATE_EMERGENCY_ONLY during
|
|
// an emergency call and when it ends, we do not want to mistakenly generate
|
|
// an OUT_OF_SERVICE disconnect cause during normal call ending.
|
|
if ((serviceState == ServiceState.STATE_OUT_OF_SERVICE
|
|
|| serviceState == ServiceState.STATE_EMERGENCY_ONLY)) {
|
|
return DisconnectCause.OUT_OF_SERVICE;
|
|
}
|
|
// If we are placing an emergency call and the SIM is currently PIN/PUK
|
|
// locked the AppState will always not be equal to APPSTATE_READY.
|
|
if (uiccAppState != AppState.APPSTATE_READY) {
|
|
if (isPhoneTypeGsm()) {
|
|
return DisconnectCause.ICC_ERROR;
|
|
} else { // CDMA
|
|
if (phone.mCdmaSubscriptionSource ==
|
|
CdmaSubscriptionSourceManager.SUBSCRIPTION_FROM_RUIM) {
|
|
return DisconnectCause.ICC_ERROR;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (isPhoneTypeGsm()) {
|
|
if (causeCode == CallFailCause.ERROR_UNSPECIFIED ||
|
|
causeCode == CallFailCause.ACCESS_CLASS_BLOCKED ) {
|
|
if (phone.mSST.mRestrictedState.isCsRestricted()) {
|
|
return DisconnectCause.CS_RESTRICTED;
|
|
} else if (phone.mSST.mRestrictedState.isCsEmergencyRestricted()) {
|
|
return DisconnectCause.CS_RESTRICTED_EMERGENCY;
|
|
} else if (phone.mSST.mRestrictedState.isCsNormalRestricted()) {
|
|
return DisconnectCause.CS_RESTRICTED_NORMAL;
|
|
}
|
|
}
|
|
}
|
|
if (causeCode == CallFailCause.NORMAL_CLEARING) {
|
|
return DisconnectCause.NORMAL;
|
|
}
|
|
// If nothing else matches, report unknown call drop reason
|
|
// to app, not NORMAL call end.
|
|
return DisconnectCause.ERROR_UNSPECIFIED;
|
|
}
|
|
}
|
|
|
|
/*package*/ void
|
|
onRemoteDisconnect(int causeCode, String vendorCause) {
|
|
this.mPreciseCause = causeCode;
|
|
this.mVendorCause = vendorCause;
|
|
onDisconnect(disconnectCauseFromCode(causeCode));
|
|
}
|
|
|
|
/**
|
|
* Called when the radio indicates the connection has been disconnected.
|
|
* @param cause call disconnect cause; values are defined in {@link DisconnectCause}
|
|
*/
|
|
@Override
|
|
public boolean onDisconnect(int cause) {
|
|
boolean changed = false;
|
|
|
|
mCause = cause;
|
|
|
|
if (!mDisconnected) {
|
|
doDisconnect();
|
|
|
|
if (DBG) Rlog.d(LOG_TAG, "onDisconnect: cause=" + cause);
|
|
|
|
mOwner.getPhone().notifyDisconnect(this);
|
|
notifyDisconnect(cause);
|
|
|
|
if (mParent != null) {
|
|
changed = mParent.connectionDisconnected(this);
|
|
}
|
|
|
|
mOrigConnection = null;
|
|
}
|
|
clearPostDialListeners();
|
|
releaseWakeLock();
|
|
return changed;
|
|
}
|
|
|
|
//CDMA
|
|
/** Called when the call waiting connection has been hung up */
|
|
/*package*/ void
|
|
onLocalDisconnect() {
|
|
if (!mDisconnected) {
|
|
doDisconnect();
|
|
if (VDBG) Rlog.d(LOG_TAG, "onLoalDisconnect" );
|
|
|
|
if (mParent != null) {
|
|
mParent.detach(this);
|
|
}
|
|
}
|
|
releaseWakeLock();
|
|
}
|
|
|
|
// Returns true if state has changed, false if nothing changed
|
|
public boolean
|
|
update (DriverCall dc) {
|
|
GsmCdmaCall newParent;
|
|
boolean changed = false;
|
|
boolean wasConnectingInOrOut = isConnectingInOrOut();
|
|
boolean wasHolding = (getState() == GsmCdmaCall.State.HOLDING);
|
|
|
|
newParent = parentFromDCState(dc.state);
|
|
|
|
if (Phone.DEBUG_PHONE) log("parent= " +mParent +", newParent= " + newParent);
|
|
|
|
//Ignore dc.number and dc.name in case of a handover connection
|
|
if (isPhoneTypeGsm() && mOrigConnection != null) {
|
|
if (Phone.DEBUG_PHONE) log("update: mOrigConnection is not null");
|
|
} else if (isIncoming()) {
|
|
if (!equalsBaseDialString(mAddress, dc.number) && (!mNumberConverted
|
|
|| !equalsBaseDialString(mConvertedNumber, dc.number))) {
|
|
if (Phone.DEBUG_PHONE) log("update: phone # changed!");
|
|
mAddress = dc.number;
|
|
changed = true;
|
|
}
|
|
}
|
|
|
|
int newAudioQuality = getAudioQualityFromDC(dc.audioQuality);
|
|
if (getAudioQuality() != newAudioQuality) {
|
|
if (Phone.DEBUG_PHONE) {
|
|
log("update: audioQuality # changed!: "
|
|
+ (newAudioQuality == Connection.AUDIO_QUALITY_HIGH_DEFINITION
|
|
? "high" : "standard"));
|
|
}
|
|
setAudioQuality(newAudioQuality);
|
|
changed = true;
|
|
}
|
|
|
|
// Metrics for audio codec
|
|
if (dc.audioQuality != mAudioCodec) {
|
|
mAudioCodec = dc.audioQuality;
|
|
mMetrics.writeAudioCodecGsmCdma(mOwner.getPhone().getPhoneId(), dc.audioQuality);
|
|
mOwner.getPhone().getVoiceCallSessionStats().onAudioCodecChanged(this, dc.audioQuality);
|
|
}
|
|
|
|
String forwardedNumber = TextUtils.isEmpty(dc.forwardedNumber) ? null : dc.forwardedNumber;
|
|
Rlog.i(LOG_TAG, "update: forwardedNumber=" + Rlog.pii(LOG_TAG, forwardedNumber));
|
|
ArrayList<String> forwardedNumbers = forwardedNumber == null ? null :
|
|
new ArrayList<>(Collections.singletonList(dc.forwardedNumber));
|
|
if (!equalsHandlesNulls(mForwardedNumber, forwardedNumbers)) {
|
|
if (Phone.DEBUG_PHONE) log("update: mForwardedNumber, # changed");
|
|
mForwardedNumber = forwardedNumbers;
|
|
changed = true;
|
|
}
|
|
|
|
// A null cnapName should be the same as ""
|
|
if (TextUtils.isEmpty(dc.name)) {
|
|
if (!TextUtils.isEmpty(mCnapName)) {
|
|
changed = true;
|
|
mCnapName = "";
|
|
}
|
|
} else if (!dc.name.equals(mCnapName)) {
|
|
changed = true;
|
|
mCnapName = dc.name;
|
|
}
|
|
|
|
if (Phone.DEBUG_PHONE) log("--dssds----"+mCnapName);
|
|
mCnapNamePresentation = dc.namePresentation;
|
|
mNumberPresentation = dc.numberPresentation;
|
|
|
|
if (newParent != mParent) {
|
|
if (mParent != null) {
|
|
mParent.detach(this);
|
|
}
|
|
newParent.attach(this, dc);
|
|
mParent = newParent;
|
|
changed = true;
|
|
} else {
|
|
boolean parentStateChange;
|
|
parentStateChange = mParent.update (this, dc);
|
|
changed = changed || parentStateChange;
|
|
}
|
|
|
|
/** Some state-transition events */
|
|
|
|
if (Phone.DEBUG_PHONE) log(
|
|
"update: parent=" + mParent +
|
|
", hasNewParent=" + (newParent != mParent) +
|
|
", wasConnectingInOrOut=" + wasConnectingInOrOut +
|
|
", wasHolding=" + wasHolding +
|
|
", isConnectingInOrOut=" + isConnectingInOrOut() +
|
|
", changed=" + changed);
|
|
|
|
|
|
if (wasConnectingInOrOut && !isConnectingInOrOut()) {
|
|
onConnectedInOrOut();
|
|
}
|
|
|
|
if (changed && !wasHolding && (getState() == GsmCdmaCall.State.HOLDING)) {
|
|
// We've transitioned into HOLDING
|
|
onStartedHolding();
|
|
}
|
|
|
|
return changed;
|
|
}
|
|
|
|
/**
|
|
* Called when this Connection is in the foregroundCall
|
|
* when a dial is initiated.
|
|
* We know we're ACTIVE, and we know we're going to end up
|
|
* HOLDING in the backgroundCall
|
|
*/
|
|
void
|
|
fakeHoldBeforeDial() {
|
|
if (mParent != null) {
|
|
mParent.detach(this);
|
|
}
|
|
|
|
mParent = mOwner.mBackgroundCall;
|
|
mParent.attachFake(this, GsmCdmaCall.State.HOLDING);
|
|
|
|
onStartedHolding();
|
|
}
|
|
|
|
/*package*/ int
|
|
getGsmCdmaIndex() throws CallStateException {
|
|
if (mIndex >= 0) {
|
|
return mIndex + 1;
|
|
} else {
|
|
throw new CallStateException ("GsmCdma index not yet assigned");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* An incoming or outgoing call has connected
|
|
*/
|
|
@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.R, trackingBug = 170729553)
|
|
void
|
|
onConnectedInOrOut() {
|
|
mConnectTime = System.currentTimeMillis();
|
|
mConnectTimeReal = SystemClock.elapsedRealtime();
|
|
mDuration = 0;
|
|
|
|
// bug #678474: incoming call interpreted as missed call, even though
|
|
// it sounds like the user has picked up the call.
|
|
if (Phone.DEBUG_PHONE) {
|
|
log("onConnectedInOrOut: connectTime=" + mConnectTime);
|
|
}
|
|
|
|
if (!mIsIncoming) {
|
|
// outgoing calls only
|
|
processNextPostDialChar();
|
|
} else {
|
|
// Only release wake lock for incoming calls, for outgoing calls the wake lock
|
|
// will be released after any pause-dial is completed
|
|
releaseWakeLock();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* We have completed the migration of another connection to this GsmCdmaConnection (for example,
|
|
* in the case of SRVCC) and not still DIALING/ALERTING/INCOMING/WAITING.
|
|
*/
|
|
void onConnectedConnectionMigrated() {
|
|
// We can release the wakelock in this case, the migrated call is not still
|
|
// DIALING/ALERTING/INCOMING/WAITING.
|
|
releaseWakeLock();
|
|
}
|
|
|
|
private void
|
|
doDisconnect() {
|
|
mIndex = -1;
|
|
mDisconnectTime = System.currentTimeMillis();
|
|
mDuration = SystemClock.elapsedRealtime() - mConnectTimeReal;
|
|
mDisconnected = true;
|
|
clearPostDialListeners();
|
|
}
|
|
|
|
/*package*/ void
|
|
onStartedHolding() {
|
|
mHoldingStartTime = SystemClock.elapsedRealtime();
|
|
}
|
|
|
|
/**
|
|
* Performs the appropriate action for a post-dial char, but does not
|
|
* notify application. returns false if the character is invalid and
|
|
* should be ignored
|
|
*/
|
|
private boolean
|
|
processPostDialChar(char c) {
|
|
if (PhoneNumberUtils.is12Key(c)) {
|
|
mOwner.mCi.sendDtmf(c, mHandler.obtainMessage(EVENT_DTMF_DONE));
|
|
} else if (isPause(c)) {
|
|
if (!isPhoneTypeGsm()) {
|
|
setPostDialState(PostDialState.PAUSE);
|
|
}
|
|
// From TS 22.101:
|
|
// It continues...
|
|
// Upon the called party answering the UE shall send the DTMF digits
|
|
// automatically to the network after a delay of 3 seconds( 20 ).
|
|
// The digits shall be sent according to the procedures and timing
|
|
// specified in 3GPP TS 24.008 [13]. The first occurrence of the
|
|
// "DTMF Control Digits Separator" shall be used by the ME to
|
|
// distinguish between the addressing digits (i.e. the phone number)
|
|
// and the DTMF digits. Upon subsequent occurrences of the
|
|
// separator,
|
|
// the UE shall pause again for 3 seconds ( 20 ) before sending
|
|
// any further DTMF digits.
|
|
mHandler.sendMessageDelayed(mHandler.obtainMessage(EVENT_PAUSE_DONE),
|
|
isPhoneTypeGsm() ? PAUSE_DELAY_MILLIS_GSM: PAUSE_DELAY_MILLIS_CDMA);
|
|
} else if (isWait(c)) {
|
|
setPostDialState(PostDialState.WAIT);
|
|
} else if (isWild(c)) {
|
|
setPostDialState(PostDialState.WILD);
|
|
} else {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public String
|
|
getRemainingPostDialString() {
|
|
String subStr = super.getRemainingPostDialString();
|
|
if (!isPhoneTypeGsm() && !TextUtils.isEmpty(subStr)) {
|
|
int wIndex = subStr.indexOf(PhoneNumberUtils.WAIT);
|
|
int pIndex = subStr.indexOf(PhoneNumberUtils.PAUSE);
|
|
|
|
if (wIndex > 0 && (wIndex < pIndex || pIndex <= 0)) {
|
|
subStr = subStr.substring(0, wIndex);
|
|
} else if (pIndex > 0) {
|
|
subStr = subStr.substring(0, pIndex);
|
|
}
|
|
}
|
|
return subStr;
|
|
}
|
|
|
|
//CDMA
|
|
@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.R, trackingBug = 170729553)
|
|
public void updateParent(GsmCdmaCall oldParent, GsmCdmaCall newParent){
|
|
if (newParent != oldParent) {
|
|
if (oldParent != null) {
|
|
oldParent.detach(this);
|
|
}
|
|
newParent.attachFake(this, GsmCdmaCall.State.ACTIVE);
|
|
mParent = newParent;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
protected void finalize()
|
|
{
|
|
/**
|
|
* It is understood that This finalizer is not guaranteed
|
|
* to be called and the release lock call is here just in
|
|
* case there is some path that doesn't call onDisconnect
|
|
* and or onConnectedInOrOut.
|
|
*/
|
|
if (mPartialWakeLock != null && mPartialWakeLock.isHeld()) {
|
|
Rlog.e(LOG_TAG, "UNEXPECTED; mPartialWakeLock is held when finalizing.");
|
|
}
|
|
clearPostDialListeners();
|
|
releaseWakeLock();
|
|
}
|
|
|
|
private void
|
|
processNextPostDialChar() {
|
|
char c = 0;
|
|
Registrant postDialHandler;
|
|
|
|
if (mPostDialState == PostDialState.CANCELLED) {
|
|
releaseWakeLock();
|
|
return;
|
|
}
|
|
|
|
if (mPostDialString == null ||
|
|
mPostDialString.length() <= mNextPostDialChar) {
|
|
setPostDialState(PostDialState.COMPLETE);
|
|
|
|
// We were holding a wake lock until pause-dial was complete, so give it up now
|
|
releaseWakeLock();
|
|
|
|
// notifyMessage.arg1 is 0 on complete
|
|
c = 0;
|
|
} else {
|
|
boolean isValid;
|
|
|
|
setPostDialState(PostDialState.STARTED);
|
|
|
|
c = mPostDialString.charAt(mNextPostDialChar++);
|
|
|
|
isValid = processPostDialChar(c);
|
|
|
|
if (!isValid) {
|
|
// Will call processNextPostDialChar
|
|
mHandler.obtainMessage(EVENT_NEXT_POST_DIAL).sendToTarget();
|
|
// Don't notify application
|
|
Rlog.e(LOG_TAG, "processNextPostDialChar: c=" + c + " isn't valid!");
|
|
return;
|
|
}
|
|
}
|
|
|
|
notifyPostDialListenersNextChar(c);
|
|
|
|
// TODO: remove the following code since the handler no longer executes anything.
|
|
postDialHandler = mOwner.getPhone().getPostDialHandler();
|
|
|
|
Message notifyMessage;
|
|
|
|
if (postDialHandler != null
|
|
&& (notifyMessage = postDialHandler.messageForRegistrant()) != null) {
|
|
// The AsyncResult.result is the Connection object
|
|
PostDialState state = mPostDialState;
|
|
AsyncResult ar = AsyncResult.forMessage(notifyMessage);
|
|
ar.result = this;
|
|
ar.userObj = state;
|
|
|
|
// arg1 is the character that was/is being processed
|
|
notifyMessage.arg1 = c;
|
|
|
|
//Rlog.v("GsmCdma", "##### processNextPostDialChar: send msg to postDialHandler, arg1=" + c);
|
|
notifyMessage.sendToTarget();
|
|
}
|
|
}
|
|
|
|
/** "connecting" means "has never been ACTIVE" for both incoming
|
|
* and outgoing calls
|
|
*/
|
|
private boolean
|
|
isConnectingInOrOut() {
|
|
return mParent == null || mParent == mOwner.mRingingCall
|
|
|| mParent.mState == GsmCdmaCall.State.DIALING
|
|
|| mParent.mState == GsmCdmaCall.State.ALERTING;
|
|
}
|
|
|
|
private GsmCdmaCall
|
|
parentFromDCState (DriverCall.State state) {
|
|
switch (state) {
|
|
case ACTIVE:
|
|
case DIALING:
|
|
case ALERTING:
|
|
return mOwner.mForegroundCall;
|
|
//break;
|
|
|
|
case HOLDING:
|
|
return mOwner.mBackgroundCall;
|
|
//break;
|
|
|
|
case INCOMING:
|
|
case WAITING:
|
|
return mOwner.mRingingCall;
|
|
//break;
|
|
|
|
default:
|
|
throw new RuntimeException("illegal call state: " + state);
|
|
}
|
|
}
|
|
|
|
private int getAudioQualityFromDC(int audioQuality) {
|
|
switch (audioQuality) {
|
|
case DriverCall.AUDIO_QUALITY_AMR_WB:
|
|
case DriverCall.AUDIO_QUALITY_EVRC_NW:
|
|
return Connection.AUDIO_QUALITY_HIGH_DEFINITION;
|
|
default:
|
|
return Connection.AUDIO_QUALITY_STANDARD;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Set post dial state and acquire wake lock while switching to "started" or "pause"
|
|
* state, the wake lock will be released if state switches out of "started" or "pause"
|
|
* state or after WAKE_LOCK_TIMEOUT_MILLIS.
|
|
* @param s new PostDialState
|
|
*/
|
|
private void setPostDialState(PostDialState s) {
|
|
if (s == PostDialState.STARTED
|
|
|| s == PostDialState.PAUSE) {
|
|
synchronized (mPartialWakeLock) {
|
|
if (mPartialWakeLock.isHeld()) {
|
|
mHandler.removeMessages(EVENT_WAKE_LOCK_TIMEOUT);
|
|
} else {
|
|
acquireWakeLock();
|
|
}
|
|
Message msg = mHandler.obtainMessage(EVENT_WAKE_LOCK_TIMEOUT);
|
|
mHandler.sendMessageDelayed(msg, WAKE_LOCK_TIMEOUT_MILLIS);
|
|
}
|
|
} else {
|
|
mHandler.removeMessages(EVENT_WAKE_LOCK_TIMEOUT);
|
|
releaseWakeLock();
|
|
}
|
|
mPostDialState = s;
|
|
notifyPostDialListeners();
|
|
}
|
|
|
|
@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.R, trackingBug = 170729553)
|
|
private void createWakeLock(Context context) {
|
|
PowerManager pm = (PowerManager) context.getSystemService(Context.POWER_SERVICE);
|
|
mPartialWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, LOG_TAG);
|
|
}
|
|
|
|
@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.R, trackingBug = 170729553)
|
|
private void acquireWakeLock() {
|
|
if (mPartialWakeLock != null) {
|
|
synchronized (mPartialWakeLock) {
|
|
log("acquireWakeLock");
|
|
mPartialWakeLock.acquire();
|
|
}
|
|
}
|
|
}
|
|
|
|
private void releaseWakeLock() {
|
|
if (mPartialWakeLock != null) {
|
|
synchronized (mPartialWakeLock) {
|
|
if (mPartialWakeLock.isHeld()) {
|
|
log("releaseWakeLock");
|
|
mPartialWakeLock.release();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void releaseAllWakeLocks() {
|
|
if (mPartialWakeLock != null) {
|
|
synchronized (mPartialWakeLock) {
|
|
while (mPartialWakeLock.isHeld()) {
|
|
mPartialWakeLock.release();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.R, trackingBug = 170729553)
|
|
private static boolean isPause(char c) {
|
|
return c == PhoneNumberUtils.PAUSE;
|
|
}
|
|
|
|
@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.R, trackingBug = 170729553)
|
|
private static boolean isWait(char c) {
|
|
return c == PhoneNumberUtils.WAIT;
|
|
}
|
|
|
|
private static boolean isWild(char c) {
|
|
return c == PhoneNumberUtils.WILD;
|
|
}
|
|
|
|
//CDMA
|
|
// This function is to find the next PAUSE character index if
|
|
// multiple pauses in a row. Otherwise it finds the next non PAUSE or
|
|
// non WAIT character index.
|
|
@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.R, trackingBug = 170729553)
|
|
private static int findNextPCharOrNonPOrNonWCharIndex(String phoneNumber, int currIndex) {
|
|
boolean wMatched = isWait(phoneNumber.charAt(currIndex));
|
|
int index = currIndex + 1;
|
|
int length = phoneNumber.length();
|
|
while (index < length) {
|
|
char cNext = phoneNumber.charAt(index);
|
|
// if there is any W inside P/W sequence,mark it
|
|
if (isWait(cNext)) {
|
|
wMatched = true;
|
|
}
|
|
// if any characters other than P/W chars after P/W sequence
|
|
// we break out the loop and append the correct
|
|
if (!isWait(cNext) && !isPause(cNext)) {
|
|
break;
|
|
}
|
|
index++;
|
|
}
|
|
|
|
// It means the PAUSE character(s) is in the middle of dial string
|
|
// and it needs to be handled one by one.
|
|
if ((index < length) && (index > (currIndex + 1)) &&
|
|
((wMatched == false) && isPause(phoneNumber.charAt(currIndex)))) {
|
|
return (currIndex + 1);
|
|
}
|
|
return index;
|
|
}
|
|
|
|
// CDMA
|
|
// This function returns either PAUSE or WAIT character to append.
|
|
// It is based on the next non PAUSE/WAIT character in the phoneNumber and the
|
|
// index for the current PAUSE/WAIT character
|
|
@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.R, trackingBug = 170729553)
|
|
private static char findPOrWCharToAppend(String phoneNumber, int currPwIndex,
|
|
int nextNonPwCharIndex) {
|
|
char c = phoneNumber.charAt(currPwIndex);
|
|
char ret;
|
|
|
|
// Append the PW char
|
|
ret = (isPause(c)) ? PhoneNumberUtils.PAUSE : PhoneNumberUtils.WAIT;
|
|
|
|
// If the nextNonPwCharIndex is greater than currPwIndex + 1,
|
|
// it means the PW sequence contains not only P characters.
|
|
// Since for the sequence that only contains P character,
|
|
// the P character is handled one by one, the nextNonPwCharIndex
|
|
// equals to currPwIndex + 1.
|
|
// In this case, skip P, append W.
|
|
if (nextNonPwCharIndex > (currPwIndex + 1)) {
|
|
ret = PhoneNumberUtils.WAIT;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.R, trackingBug = 170729553)
|
|
private String maskDialString(String dialString) {
|
|
if (VDBG) {
|
|
return dialString;
|
|
}
|
|
|
|
return "<MASKED>";
|
|
}
|
|
|
|
@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.R, trackingBug = 170729553)
|
|
private void fetchDtmfToneDelay(GsmCdmaPhone phone) {
|
|
CarrierConfigManager configMgr = (CarrierConfigManager)
|
|
phone.getContext().getSystemService(Context.CARRIER_CONFIG_SERVICE);
|
|
PersistableBundle b = configMgr.getConfigForSubId(phone.getSubId());
|
|
if (b != null) {
|
|
mDtmfToneDelay = b.getInt(phone.getDtmfToneDelayKey());
|
|
}
|
|
}
|
|
|
|
@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.R, trackingBug = 170729553)
|
|
private boolean isPhoneTypeGsm() {
|
|
return mOwner.getPhone().getPhoneType() == PhoneConstants.PHONE_TYPE_GSM;
|
|
}
|
|
|
|
@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.R, trackingBug = 170729553)
|
|
private void log(String msg) {
|
|
Rlog.d(LOG_TAG, "[GsmCdmaConn] " + msg);
|
|
}
|
|
|
|
@Override
|
|
public int getNumberPresentation() {
|
|
return mNumberPresentation;
|
|
}
|
|
|
|
@Override
|
|
public UUSInfo getUUSInfo() {
|
|
return mUusInfo;
|
|
}
|
|
|
|
public int getPreciseDisconnectCause() {
|
|
return mPreciseCause;
|
|
}
|
|
|
|
@Override
|
|
public String getVendorDisconnectCause() {
|
|
return mVendorCause;
|
|
}
|
|
|
|
@Override
|
|
public void migrateFrom(Connection c) {
|
|
if (c == null) return;
|
|
|
|
super.migrateFrom(c);
|
|
|
|
this.mUusInfo = c.getUUSInfo();
|
|
|
|
this.setUserData(c.getUserData());
|
|
}
|
|
|
|
@Override
|
|
public Connection getOrigConnection() {
|
|
return mOrigConnection;
|
|
}
|
|
|
|
@Override
|
|
public boolean isMultiparty() {
|
|
if (mOrigConnection != null) {
|
|
return mOrigConnection.isMultiparty();
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Get the corresponding EmergencyNumberTracker associated with the connection.
|
|
* @return the EmergencyNumberTracker
|
|
*/
|
|
public EmergencyNumberTracker getEmergencyNumberTracker() {
|
|
if (mOwner != null) {
|
|
Phone phone = mOwner.getPhone();
|
|
if (phone != null) {
|
|
return phone.getEmergencyNumberTracker();
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* @return {@code true} if this call is an OTASP activation call, {@code false} otherwise.
|
|
*/
|
|
public boolean isOtaspCall() {
|
|
return mAddress != null && OTASP_NUMBER.equals(mAddress);
|
|
}
|
|
}
|