/*
* Copyright (C) 2013 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.imsphone;
import android.app.ActivityManagerNative;
import android.content.Context;
import android.content.Intent;
import android.os.AsyncResult;
import android.os.Handler;
import android.os.Message;
import android.os.PowerManager;
import android.os.Registrant;
import android.os.RegistrantList;
import android.os.PowerManager.WakeLock;
import android.os.SystemProperties;
import android.os.UserHandle;
import android.telephony.PhoneNumberUtils;
import android.telephony.ServiceState;
import android.telephony.Rlog;
import android.telephony.SubscriptionManager;
import android.text.TextUtils;
import com.android.ims.ImsCallForwardInfo;
import com.android.ims.ImsCallProfile;
import com.android.ims.ImsEcbm;
import com.android.ims.ImsEcbmStateListener;
import com.android.ims.ImsException;
import com.android.ims.ImsReasonInfo;
import com.android.ims.ImsSsInfo;
import com.android.ims.ImsUtInterface;
import static com.android.internal.telephony.CommandsInterface.CB_FACILITY_BAOC;
import static com.android.internal.telephony.CommandsInterface.CB_FACILITY_BAOIC;
import static com.android.internal.telephony.CommandsInterface.CB_FACILITY_BAOICxH;
import static com.android.internal.telephony.CommandsInterface.CB_FACILITY_BAIC;
import static com.android.internal.telephony.CommandsInterface.CB_FACILITY_BAICr;
import static com.android.internal.telephony.CommandsInterface.CB_FACILITY_BA_ALL;
import static com.android.internal.telephony.CommandsInterface.CB_FACILITY_BA_MO;
import static com.android.internal.telephony.CommandsInterface.CB_FACILITY_BA_MT;
import static com.android.internal.telephony.CommandsInterface.CF_ACTION_DISABLE;
import static com.android.internal.telephony.CommandsInterface.CF_ACTION_ENABLE;
import static com.android.internal.telephony.CommandsInterface.CF_ACTION_ERASURE;
import static com.android.internal.telephony.CommandsInterface.CF_ACTION_REGISTRATION;
import static com.android.internal.telephony.CommandsInterface.CF_REASON_ALL;
import static com.android.internal.telephony.CommandsInterface.CF_REASON_ALL_CONDITIONAL;
import static com.android.internal.telephony.CommandsInterface.CF_REASON_NO_REPLY;
import static com.android.internal.telephony.CommandsInterface.CF_REASON_NOT_REACHABLE;
import static com.android.internal.telephony.CommandsInterface.CF_REASON_BUSY;
import static com.android.internal.telephony.CommandsInterface.CF_REASON_UNCONDITIONAL;
import static com.android.internal.telephony.CommandsInterface.SERVICE_CLASS_VOICE;
import static com.android.internal.telephony.CommandsInterface.SERVICE_CLASS_NONE;
import com.android.internal.telephony.Call;
import com.android.internal.telephony.CallForwardInfo;
import com.android.internal.telephony.CallStateException;
import com.android.internal.telephony.CallTracker;
import com.android.internal.telephony.CommandException;
import com.android.internal.telephony.CommandsInterface;
import com.android.internal.telephony.Connection;
import com.android.internal.telephony.Phone;
import com.android.internal.telephony.PhoneBase;
import com.android.internal.telephony.PhoneConstants;
import com.android.internal.telephony.PhoneNotifier;
import com.android.internal.telephony.TelephonyIntents;
import com.android.internal.telephony.TelephonyProperties;
import com.android.internal.telephony.cdma.CDMAPhone;
import com.android.internal.telephony.gsm.GSMPhone;
import com.android.internal.telephony.uicc.IccRecords;
import java.util.ArrayList;
import java.util.List;
/**
* {@hide}
*/
public class ImsPhone extends ImsPhoneBase {
private static final String LOG_TAG = "ImsPhone";
private static final boolean DBG = true;
private static final boolean VDBG = false; // STOPSHIP if true
protected static final int EVENT_SET_CALL_BARRING_DONE = EVENT_LAST + 1;
protected static final int EVENT_GET_CALL_BARRING_DONE = EVENT_LAST + 2;
protected static final int EVENT_SET_CALL_WAITING_DONE = EVENT_LAST + 3;
protected static final int EVENT_GET_CALL_WAITING_DONE = EVENT_LAST + 4;
public static final String CS_FALLBACK = "cs_fallback";
static final int RESTART_ECM_TIMER = 0; // restart Ecm timer
static final int CANCEL_ECM_TIMER = 1; // cancel Ecm timer
// Default Emergency Callback Mode exit timer
private static final int DEFAULT_ECM_EXIT_TIMER_VALUE = 300000;
// Instance Variables
PhoneBase mDefaultPhone;
ImsPhoneCallTracker mCT;
ArrayList <ImsPhoneMmiCode> mPendingMMIs = new ArrayList<ImsPhoneMmiCode>();
Registrant mPostDialHandler;
ServiceState mSS = new ServiceState();
// To redial silently through GSM or CDMA when dialing through IMS fails
private String mLastDialString;
WakeLock mWakeLock;
protected boolean mIsPhoneInEcmState;
// mEcmExitRespRegistrant is informed after the phone has been exited the emergency
// callback mode keep track of if phone is in emergency callback mode
private Registrant mEcmExitRespRegistrant;
private final RegistrantList mSilentRedialRegistrants = new RegistrantList();
private boolean mImsRegistered = false;
// A runnable which is used to automatically exit from Ecm after a period of time.
private Runnable mExitEcmRunnable = new Runnable() {
@Override
public void run() {
exitEmergencyCallbackMode();
}
};
// Create Cf (Call forward) so that dialling number &
// mIsCfu (true if reason is call forward unconditional)
// mOnComplete (Message object passed by client) can be packed &
// given as a single Cf object as user data to UtInterface.
private static class Cf {
final String mSetCfNumber;
final Message mOnComplete;
final boolean mIsCfu;
Cf(String cfNumber, boolean isCfu, Message onComplete) {
mSetCfNumber = cfNumber;
mIsCfu = isCfu;
mOnComplete = onComplete;
}
}
// Constructors
ImsPhone(Context context, PhoneNotifier notifier, Phone defaultPhone) {
super("ImsPhone", context, notifier);
mDefaultPhone = (PhoneBase) defaultPhone;
mCT = new ImsPhoneCallTracker(this);
mSS.setStateOff();
mPhoneId = mDefaultPhone.getPhoneId();
// This is needed to handle phone process crashes
// Same property is used for both CDMA & IMS phone.
mIsPhoneInEcmState = SystemProperties.getBoolean(
TelephonyProperties.PROPERTY_INECM_MODE, false);
PowerManager pm = (PowerManager) context.getSystemService(Context.POWER_SERVICE);
mWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, LOG_TAG);
mWakeLock.setReferenceCounted(false);
}
public void updateParentPhone(PhoneBase parentPhone) {
// synchronization is managed at the PhoneBase scope (which calls this function)
mDefaultPhone = parentPhone;
mPhoneId = mDefaultPhone.getPhoneId();
}
@Override
public void dispose() {
Rlog.d(LOG_TAG, "dispose");
// Nothing to dispose in PhoneBase
//super.dispose();
mPendingMMIs.clear();
mCT.dispose();
//Force all referenced classes to unregister their former registered events
}
@Override
public void removeReferences() {
Rlog.d(LOG_TAG, "removeReferences");
super.removeReferences();
mCT = null;
mSS = null;
}
@Override
public ServiceState
getServiceState() {
return mSS;
}
/* package */ void setServiceState(int state) {
mSS.setState(state);
}
@Override
public CallTracker getCallTracker() {
return mCT;
}
@Override
public List<? extends ImsPhoneMmiCode>
getPendingMmiCodes() {
return mPendingMMIs;
}
@Override
public void
acceptCall(int videoState) throws CallStateException {
mCT.acceptCall(videoState);
}
@Override
public void
rejectCall() throws CallStateException {
mCT.rejectCall();
}
@Override
public void
switchHoldingAndActive() throws CallStateException {
mCT.switchWaitingOrHoldingAndActive();
}
@Override
public boolean canConference() {
return mCT.canConference();
}
public boolean canDial() {
return mCT.canDial();
}
@Override
public void conference() {
mCT.conference();
}
@Override
public void clearDisconnected() {
mCT.clearDisconnected();
}
@Override
public boolean canTransfer() {
return mCT.canTransfer();
}
@Override
public void explicitCallTransfer() {
mCT.explicitCallTransfer();
}
@Override
public ImsPhoneCall
getForegroundCall() {
return mCT.mForegroundCall;
}
@Override
public ImsPhoneCall
getBackgroundCall() {
return mCT.mBackgroundCall;
}
@Override
public ImsPhoneCall
getRingingCall() {
return mCT.mRingingCall;
}
private boolean handleCallDeflectionIncallSupplementaryService(
String dialString) {
if (dialString.length() > 1) {
return false;
}
if (getRingingCall().getState() != ImsPhoneCall.State.IDLE) {
if (DBG) Rlog.d(LOG_TAG, "MmiCode 0: rejectCall");
try {
mCT.rejectCall();
} catch (CallStateException e) {
if (DBG) Rlog.d(LOG_TAG, "reject failed", e);
notifySuppServiceFailed(Phone.SuppService.REJECT);
}
} else if (getBackgroundCall().getState() != ImsPhoneCall.State.IDLE) {
if (DBG) Rlog.d(LOG_TAG, "MmiCode 0: hangupWaitingOrBackground");
try {
mCT.hangup(getBackgroundCall());
} catch (CallStateException e) {
if (DBG) Rlog.d(LOG_TAG, "hangup failed", e);
}
}
return true;
}
private boolean handleCallWaitingIncallSupplementaryService(
String dialString) {
int len = dialString.length();
if (len > 2) {
return false;
}
ImsPhoneCall call = getForegroundCall();
try {
if (len > 1) {
if (DBG) Rlog.d(LOG_TAG, "not support 1X SEND");
notifySuppServiceFailed(Phone.SuppService.HANGUP);
} else {
if (call.getState() != ImsPhoneCall.State.IDLE) {
if (DBG) Rlog.d(LOG_TAG, "MmiCode 1: hangup foreground");
mCT.hangup(call);
} else {
if (DBG) Rlog.d(LOG_TAG, "MmiCode 1: switchWaitingOrHoldingAndActive");
mCT.switchWaitingOrHoldingAndActive();
}
}
} catch (CallStateException e) {
if (DBG) Rlog.d(LOG_TAG, "hangup failed", e);
notifySuppServiceFailed(Phone.SuppService.HANGUP);
}
return true;
}
private boolean handleCallHoldIncallSupplementaryService(String dialString) {
int len = dialString.length();
if (len > 2) {
return false;
}
ImsPhoneCall call = getForegroundCall();
if (len > 1) {
if (DBG) Rlog.d(LOG_TAG, "separate not supported");
notifySuppServiceFailed(Phone.SuppService.SEPARATE);
} else {
try {
if (getRingingCall().getState() != ImsPhoneCall.State.IDLE) {
if (DBG) Rlog.d(LOG_TAG, "MmiCode 2: accept ringing call");
mCT.acceptCall(ImsCallProfile.CALL_TYPE_VOICE);
} else {
if (DBG) Rlog.d(LOG_TAG, "MmiCode 2: switchWaitingOrHoldingAndActive");
mCT.switchWaitingOrHoldingAndActive();
}
} catch (CallStateException e) {
if (DBG) Rlog.d(LOG_TAG, "switch failed", e);
notifySuppServiceFailed(Phone.SuppService.SWITCH);
}
}
return true;
}
private boolean handleMultipartyIncallSupplementaryService(
String dialString) {
if (dialString.length() > 1) {
return false;
}
if (DBG) Rlog.d(LOG_TAG, "MmiCode 3: merge calls");
conference();
return true;
}
private boolean handleEctIncallSupplementaryService(String dialString) {
int len = dialString.length();
if (len != 1) {
return false;
}
if (DBG) Rlog.d(LOG_TAG, "MmiCode 4: not support explicit call transfer");
notifySuppServiceFailed(Phone.SuppService.TRANSFER);
return true;
}
private boolean handleCcbsIncallSupplementaryService(String dialString) {
if (dialString.length() > 1) {
return false;
}
Rlog.i(LOG_TAG, "MmiCode 5: CCBS not supported!");
// Treat it as an "unknown" service.
notifySuppServiceFailed(Phone.SuppService.UNKNOWN);
return true;
}
@Override
public boolean handleInCallMmiCommands(String dialString) {
if (!isInCall()) {
return false;
}
if (TextUtils.isEmpty(dialString)) {
return false;
}
boolean result = false;
char ch = dialString.charAt(0);
switch (ch) {
case '0':
result = handleCallDeflectionIncallSupplementaryService(
dialString);
break;
case '1':
result = handleCallWaitingIncallSupplementaryService(
dialString);
break;
case '2':
result = handleCallHoldIncallSupplementaryService(dialString);
break;
case '3':
result = handleMultipartyIncallSupplementaryService(dialString);
break;
case '4':
result = handleEctIncallSupplementaryService(dialString);
break;
case '5':
result = handleCcbsIncallSupplementaryService(dialString);
break;
default:
break;
}
return result;
}
boolean isInCall() {
ImsPhoneCall.State foregroundCallState = getForegroundCall().getState();
ImsPhoneCall.State backgroundCallState = getBackgroundCall().getState();
ImsPhoneCall.State ringingCallState = getRingingCall().getState();
return (foregroundCallState.isAlive() ||
backgroundCallState.isAlive() ||
ringingCallState.isAlive());
}
void notifyNewRingingConnection(Connection c) {
mDefaultPhone.notifyNewRingingConnectionP(c);
}
@Override
public Connection
dial(String dialString, int videoState) throws CallStateException {
return dialInternal(dialString, videoState);
}
protected Connection dialInternal(String dialString, int videoState)
throws CallStateException {
// Need to make sure dialString gets parsed properly
String newDialString = PhoneNumberUtils.stripSeparators(dialString);
// handle in-call MMI first if applicable
if (handleInCallMmiCommands(newDialString)) {
return null;
}
if (mDefaultPhone.getPhoneType() == PhoneConstants.PHONE_TYPE_CDMA) {
return mCT.dial(dialString, videoState);
}
// Only look at the Network portion for mmi
String networkPortion = PhoneNumberUtils.extractNetworkPortionAlt(newDialString);
ImsPhoneMmiCode mmi =
ImsPhoneMmiCode.newFromDialString(networkPortion, this);
if (DBG) Rlog.d(LOG_TAG,
"dialing w/ mmi '" + mmi + "'...");
if (mmi == null) {
return mCT.dial(dialString, videoState);
} else if (mmi.isTemporaryModeCLIR()) {
return mCT.dial(mmi.getDialingNumber(), mmi.getCLIRMode(), videoState);
} else if (!mmi.isSupportedOverImsPhone()) {
// If the mmi is not supported by IMS service,
// try to initiate dialing with default phone
throw new CallStateException(CS_FALLBACK);
} else {
mPendingMMIs.add(mmi);
mMmiRegistrants.notifyRegistrants(new AsyncResult(null, mmi, null));
mmi.processCode();
return null;
}
}
@Override
public void
sendDtmf(char c) {
if (!PhoneNumberUtils.is12Key(c)) {
Rlog.e(LOG_TAG,
"sendDtmf called with invalid character '" + c + "'");
} else {
if (mCT.mState == PhoneConstants.State.OFFHOOK) {
mCT.sendDtmf(c, null);
}
}
}
@Override
public void
startDtmf(char c) {
if (!(PhoneNumberUtils.is12Key(c) || (c >= 'A' && c <= 'D'))) {
Rlog.e(LOG_TAG,
"startDtmf called with invalid character '" + c + "'");
} else {
mCT.startDtmf(c);
}
}
@Override
public void
stopDtmf() {
mCT.stopDtmf();
}
@Override
public void setOnPostDialCharacter(Handler h, int what, Object obj) {
mPostDialHandler = new Registrant(h, what, obj);
}
/*package*/ void notifyIncomingRing() {
if (DBG) Rlog.d(LOG_TAG, "notifyIncomingRing");
AsyncResult ar = new AsyncResult(null, null, null);
sendMessage(obtainMessage(EVENT_CALL_RING, ar));
}
@Override
public void setMute(boolean muted) {
mCT.setMute(muted);
}
@Override
public void setUiTTYMode(int uiTtyMode, Message onComplete) {
mCT.setUiTTYMode(uiTtyMode, onComplete);
}
@Override
public boolean getMute() {
return mCT.getMute();
}
@Override
public PhoneConstants.State getState() {
return mCT.mState;
}
private boolean isValidCommandInterfaceCFReason (int commandInterfaceCFReason) {
switch (commandInterfaceCFReason) {
case CF_REASON_UNCONDITIONAL:
case CF_REASON_BUSY:
case CF_REASON_NO_REPLY:
case CF_REASON_NOT_REACHABLE:
case CF_REASON_ALL:
case CF_REASON_ALL_CONDITIONAL:
return true;
default:
return false;
}
}
private boolean isValidCommandInterfaceCFAction (int commandInterfaceCFAction) {
switch (commandInterfaceCFAction) {
case CF_ACTION_DISABLE:
case CF_ACTION_ENABLE:
case CF_ACTION_REGISTRATION:
case CF_ACTION_ERASURE:
return true;
default:
return false;
}
}
private boolean isCfEnable(int action) {
return (action == CF_ACTION_ENABLE) || (action == CF_ACTION_REGISTRATION);
}
private int getConditionFromCFReason(int reason) {
switch(reason) {
case CF_REASON_UNCONDITIONAL: return ImsUtInterface.CDIV_CF_UNCONDITIONAL;
case CF_REASON_BUSY: return ImsUtInterface.CDIV_CF_BUSY;
case CF_REASON_NO_REPLY: return ImsUtInterface.CDIV_CF_NO_REPLY;
case CF_REASON_NOT_REACHABLE: return ImsUtInterface.CDIV_CF_NOT_REACHABLE;
case CF_REASON_ALL: return ImsUtInterface.CDIV_CF_ALL;
case CF_REASON_ALL_CONDITIONAL: return ImsUtInterface.CDIV_CF_ALL_CONDITIONAL;
default:
break;
}
return ImsUtInterface.INVALID;
}
private int getCFReasonFromCondition(int condition) {
switch(condition) {
case ImsUtInterface.CDIV_CF_UNCONDITIONAL: return CF_REASON_UNCONDITIONAL;
case ImsUtInterface.CDIV_CF_BUSY: return CF_REASON_BUSY;
case ImsUtInterface.CDIV_CF_NO_REPLY: return CF_REASON_NO_REPLY;
case ImsUtInterface.CDIV_CF_NOT_REACHABLE: return CF_REASON_NOT_REACHABLE;
case ImsUtInterface.CDIV_CF_ALL: return CF_REASON_ALL;
case ImsUtInterface.CDIV_CF_ALL_CONDITIONAL: return CF_REASON_ALL_CONDITIONAL;
default:
break;
}
return CF_REASON_NOT_REACHABLE;
}
private int getActionFromCFAction(int action) {
switch(action) {
case CF_ACTION_DISABLE: return ImsUtInterface.ACTION_DEACTIVATION;
case CF_ACTION_ENABLE: return ImsUtInterface.ACTION_ACTIVATION;
case CF_ACTION_ERASURE: return ImsUtInterface.ACTION_ERASURE;
case CF_ACTION_REGISTRATION: return ImsUtInterface.ACTION_REGISTRATION;
default:
break;
}
return ImsUtInterface.INVALID;
}
@Override
public void getCallForwardingOption(int commandInterfaceCFReason,
Message onComplete) {
if (DBG) Rlog.d(LOG_TAG, "getCallForwardingOption reason=" + commandInterfaceCFReason);
if (isValidCommandInterfaceCFReason(commandInterfaceCFReason)) {
if (DBG) Rlog.d(LOG_TAG, "requesting call forwarding query.");
Message resp;
resp = obtainMessage(EVENT_GET_CALL_FORWARD_DONE, onComplete);
try {
ImsUtInterface ut = mCT.getUtInterface();
ut.queryCallForward(getConditionFromCFReason(commandInterfaceCFReason),null,resp);
} catch (ImsException e) {
sendErrorResponse(onComplete, e);
}
} else if (onComplete != null) {
sendErrorResponse(onComplete);
}
}
@Override
public void setCallForwardingOption(int commandInterfaceCFAction,
int commandInterfaceCFReason,
String dialingNumber,
int timerSeconds,
Message onComplete) {
if (DBG) Rlog.d(LOG_TAG, "setCallForwardingOption action=" + commandInterfaceCFAction
+ ", reason=" + commandInterfaceCFReason);
if ((isValidCommandInterfaceCFAction(commandInterfaceCFAction)) &&
(isValidCommandInterfaceCFReason(commandInterfaceCFReason))) {
Message resp;
Cf cf = new Cf(dialingNumber,
(commandInterfaceCFReason == CF_REASON_UNCONDITIONAL ? true : false),
onComplete);
resp = obtainMessage(EVENT_SET_CALL_FORWARD_DONE,
isCfEnable(commandInterfaceCFAction) ? 1 : 0, 0, cf);
try {
ImsUtInterface ut = mCT.getUtInterface();
ut.updateCallForward(getActionFromCFAction(commandInterfaceCFAction),
getConditionFromCFReason(commandInterfaceCFReason),
dialingNumber,
timerSeconds,
onComplete);
} catch (ImsException e) {
sendErrorResponse(onComplete, e);
}
} else if (onComplete != null) {
sendErrorResponse(onComplete);
}
}
@Override
public void getCallWaiting(Message onComplete) {
if (DBG) Rlog.d(LOG_TAG, "getCallWaiting");
Message resp;
resp = obtainMessage(EVENT_GET_CALL_WAITING_DONE, onComplete);
try {
ImsUtInterface ut = mCT.getUtInterface();
ut.queryCallWaiting(resp);
} catch (ImsException e) {
sendErrorResponse(onComplete, e);
}
}
@Override
public void setCallWaiting(boolean enable, Message onComplete) {
if (DBG) Rlog.d(LOG_TAG, "setCallWaiting enable=" + enable);
Message resp;
resp = obtainMessage(EVENT_SET_CALL_WAITING_DONE, onComplete);
try {
ImsUtInterface ut = mCT.getUtInterface();
ut.updateCallWaiting(enable, resp);
} catch (ImsException e) {
sendErrorResponse(onComplete, e);
}
}
private int getCBTypeFromFacility(String facility) {
if (CB_FACILITY_BAOC.equals(facility)) {
return ImsUtInterface.CB_BAOC;
} else if (CB_FACILITY_BAOIC.equals(facility)) {
return ImsUtInterface.CB_BOIC;
} else if (CB_FACILITY_BAOICxH.equals(facility)) {
return ImsUtInterface.CB_BOIC_EXHC;
} else if (CB_FACILITY_BAIC.equals(facility)) {
return ImsUtInterface.CB_BAIC;
} else if (CB_FACILITY_BAICr.equals(facility)) {
return ImsUtInterface.CB_BIC_WR;
} else if (CB_FACILITY_BA_ALL.equals(facility)) {
return ImsUtInterface.CB_BA_ALL;
} else if (CB_FACILITY_BA_MO.equals(facility)) {
return ImsUtInterface.CB_BA_MO;
} else if (CB_FACILITY_BA_MT.equals(facility)) {
return ImsUtInterface.CB_BA_MT;
}
return 0;
}
/* package */
void getCallBarring(String facility, Message onComplete) {
if (DBG) Rlog.d(LOG_TAG, "getCallBarring facility=" + facility);
Message resp;
resp = obtainMessage(EVENT_GET_CALL_BARRING_DONE, onComplete);
try {
ImsUtInterface ut = mCT.getUtInterface();
ut.queryCallBarring(getCBTypeFromFacility(facility), resp);
} catch (ImsException e) {
sendErrorResponse(onComplete, e);
}
}
/* package */
void setCallBarring(String facility, boolean lockState, String password, Message onComplete) {
if (DBG) Rlog.d(LOG_TAG, "setCallBarring facility=" + facility
+ ", lockState=" + lockState);
Message resp;
resp = obtainMessage(EVENT_SET_CALL_BARRING_DONE, onComplete);
try {
ImsUtInterface ut = mCT.getUtInterface();
// password is not required with Ut interface
ut.updateCallBarring(getCBTypeFromFacility(facility), lockState, resp, null);
} catch (ImsException e) {
sendErrorResponse(onComplete, e);
}
}
@Override
public void sendUssdResponse(String ussdMessge) {
Rlog.d(LOG_TAG, "sendUssdResponse");
ImsPhoneMmiCode mmi = ImsPhoneMmiCode.newFromUssdUserInput(ussdMessge, this);
mPendingMMIs.add(mmi);
mMmiRegistrants.notifyRegistrants(new AsyncResult(null, mmi, null));
mmi.sendUssd(ussdMessge);
}
/* package */
void sendUSSD (String ussdString, Message response) {
mCT.sendUSSD(ussdString, response);
}
/* package */
void cancelUSSD() {
mCT.cancelUSSD();
}
/* package */
void sendErrorResponse(Message onComplete) {
Rlog.d(LOG_TAG, "sendErrorResponse");
if (onComplete != null) {
AsyncResult.forMessage(onComplete, null,
new CommandException(CommandException.Error.GENERIC_FAILURE));
onComplete.sendToTarget();
}
}
/* package */
void sendErrorResponse(Message onComplete, Throwable e) {
Rlog.d(LOG_TAG, "sendErrorResponse");
if (onComplete != null) {
AsyncResult.forMessage(onComplete, null, getCommandException(e));
onComplete.sendToTarget();
}
}
/* package */
void sendErrorResponse(Message onComplete, ImsReasonInfo reasonInfo) {
Rlog.d(LOG_TAG, "sendErrorResponse reasonCode=" + reasonInfo.getCode());
if (onComplete != null) {
AsyncResult.forMessage(onComplete, null, getCommandException(reasonInfo.getCode()));
onComplete.sendToTarget();
}
}
/* package */
CommandException getCommandException(int code) {
Rlog.d(LOG_TAG, "getCommandException code=" + code);
CommandException.Error error = CommandException.Error.GENERIC_FAILURE;
switch(code) {
case ImsReasonInfo.CODE_UT_NOT_SUPPORTED:
error = CommandException.Error.REQUEST_NOT_SUPPORTED;
break;
case ImsReasonInfo.CODE_UT_CB_PASSWORD_MISMATCH:
error = CommandException.Error.PASSWORD_INCORRECT;
break;
default:
break;
}
return new CommandException(error);
}
/* package */
CommandException getCommandException(Throwable e) {
CommandException ex = null;
if (e instanceof ImsException) {
ex = getCommandException(((ImsException)e).getCode());
} else {
Rlog.d(LOG_TAG, "getCommandException generic failure");
ex = new CommandException(CommandException.Error.GENERIC_FAILURE);
}
return ex;
}
private void
onNetworkInitiatedUssd(ImsPhoneMmiCode mmi) {
Rlog.d(LOG_TAG, "onNetworkInitiatedUssd");
mMmiCompleteRegistrants.notifyRegistrants(
new AsyncResult(null, mmi, null));
}
/* package */
void onIncomingUSSD (int ussdMode, String ussdMessage) {
if (DBG) Rlog.d(LOG_TAG, "onIncomingUSSD ussdMode=" + ussdMode);
boolean isUssdError;
boolean isUssdRequest;
isUssdRequest
= (ussdMode == CommandsInterface.USSD_MODE_REQUEST);
isUssdError
= (ussdMode != CommandsInterface.USSD_MODE_NOTIFY
&& ussdMode != CommandsInterface.USSD_MODE_REQUEST);
ImsPhoneMmiCode found = null;
for (int i = 0, s = mPendingMMIs.size() ; i < s; i++) {
if(mPendingMMIs.get(i).isPendingUSSD()) {
found = mPendingMMIs.get(i);
break;
}
}
if (found != null) {
// Complete pending USSD
if (isUssdError) {
found.onUssdFinishedError();
} else {
found.onUssdFinished(ussdMessage, isUssdRequest);
}
} else { // pending USSD not found
// The network may initiate its own USSD request
// ignore everything that isnt a Notify or a Request
// also, discard if there is no message to present
if (!isUssdError && ussdMessage != null) {
ImsPhoneMmiCode mmi;
mmi = ImsPhoneMmiCode.newNetworkInitiatedUssd(ussdMessage,
isUssdRequest,
ImsPhone.this);
onNetworkInitiatedUssd(mmi);
}
}
}
/**
* Removes the given MMI from the pending list and notifies
* registrants that it is complete.
* @param mmi MMI that is done
*/
/*package*/ void
onMMIDone(ImsPhoneMmiCode mmi) {
/* Only notify complete if it's on the pending list.
* Otherwise, it's already been handled (eg, previously canceled).
* The exception is cancellation of an incoming USSD-REQUEST, which is
* not on the list.
*/
if (mPendingMMIs.remove(mmi) || mmi.isUssdRequest()) {
mMmiCompleteRegistrants.notifyRegistrants(
new AsyncResult(null, mmi, null));
}
}
public ArrayList<Connection> getHandoverConnection() {
ArrayList<Connection> connList = new ArrayList<Connection>();
// Add all foreground call connections
connList.addAll(getForegroundCall().mConnections);
// Add all background call connections
connList.addAll(getBackgroundCall().mConnections);
// Add all background call connections
connList.addAll(getRingingCall().mConnections);
if (connList.size() > 0) {
return connList;
} else {
return null;
}
}
public void notifySrvccState(Call.SrvccState state) {
mCT.notifySrvccState(state);
}
/* package */ void
initiateSilentRedial() {
String result = mLastDialString;
AsyncResult ar = new AsyncResult(null, result, null);
if (ar != null) {
mSilentRedialRegistrants.notifyRegistrants(ar);
}
}
public void registerForSilentRedial(Handler h, int what, Object obj) {
mSilentRedialRegistrants.addUnique(h, what, obj);
}
public void unregisterForSilentRedial(Handler h) {
mSilentRedialRegistrants.remove(h);
}
@Override
public int getSubId() {
return mDefaultPhone.getSubId();
}
@Override
public int getPhoneId() {
return mDefaultPhone.getPhoneId();
}
private IccRecords getIccRecords() {
return mDefaultPhone.mIccRecords.get();
}
private CallForwardInfo getCallForwardInfo(ImsCallForwardInfo info) {
CallForwardInfo cfInfo = new CallForwardInfo();
cfInfo.status = info.mStatus;
cfInfo.reason = getCFReasonFromCondition(info.mCondition);
cfInfo.serviceClass = SERVICE_CLASS_VOICE;
cfInfo.toa = info.mToA;
cfInfo.number = info.mNumber;
cfInfo.timeSeconds = info.mTimeSeconds;
return cfInfo;
}
private CallForwardInfo[] handleCfQueryResult(ImsCallForwardInfo[] infos) {
CallForwardInfo[] cfInfos = null;
if (infos != null && infos.length != 0) {
cfInfos = new CallForwardInfo[infos.length];
}
IccRecords r = getIccRecords();
if (infos == null || infos.length == 0) {
if (r != null) {
// Assume the default is not active
// Set unconditional CFF in SIM to false
r.setVoiceCallForwardingFlag(1, false, null);
}
} else {
for (int i = 0, s = infos.length; i < s; i++) {
if (infos[i].mCondition == ImsUtInterface.CDIV_CF_UNCONDITIONAL) {
if (r != null) {
r.setVoiceCallForwardingFlag(1, (infos[i].mStatus == 1),
infos[i].mNumber);
}
}
cfInfos[i] = getCallForwardInfo(infos[i]);
}
}
return cfInfos;
}
private int[] handleCbQueryResult(ImsSsInfo[] infos) {
int[] cbInfos = new int[1];
cbInfos[0] = SERVICE_CLASS_NONE;
if (infos[0].mStatus == 1) {
cbInfos[0] = SERVICE_CLASS_VOICE;
}
return cbInfos;
}
private int[] handleCwQueryResult(ImsSsInfo[] infos) {
int[] cwInfos = new int[2];
cwInfos[0] = 0;
if (infos[0].mStatus == 1) {
cwInfos[0] = 1;
cwInfos[1] = SERVICE_CLASS_VOICE;
}
return cwInfos;
}
private void
sendResponse(Message onComplete, Object result, Throwable e) {
if (onComplete != null) {
CommandException ex = null;
ImsException imsEx = null;
if (e != null) {
if (e instanceof ImsException) {
imsEx = (ImsException) e;
AsyncResult.forMessage(onComplete, result, imsEx);
} else {
ex = getCommandException(e);
AsyncResult.forMessage(onComplete, result, ex);
}
} else {
AsyncResult.forMessage(onComplete, result, null);
}
onComplete.sendToTarget();
}
}
@Override
public void handleMessage (Message msg) {
AsyncResult ar = (AsyncResult) msg.obj;
Message onComplete;
if (DBG) Rlog.d(LOG_TAG, "handleMessage what=" + msg.what);
switch (msg.what) {
case EVENT_SET_CALL_FORWARD_DONE:
IccRecords r = getIccRecords();
Cf cf = (Cf) ar.userObj;
if (cf.mIsCfu && ar.exception == null && r != null) {
r.setVoiceCallForwardingFlag(1, msg.arg1 == 1, cf.mSetCfNumber);
}
sendResponse(cf.mOnComplete, null, ar.exception);
break;
case EVENT_GET_CALL_FORWARD_DONE:
CallForwardInfo[] cfInfos = null;
if (ar.exception == null) {
cfInfos = handleCfQueryResult((ImsCallForwardInfo[])ar.result);
}
sendResponse((Message) ar.userObj, cfInfos, ar.exception);
break;
case EVENT_GET_CALL_BARRING_DONE:
case EVENT_GET_CALL_WAITING_DONE:
int[] ssInfos = null;
if (ar.exception == null) {
if (msg.what == EVENT_GET_CALL_BARRING_DONE) {
ssInfos = handleCbQueryResult((ImsSsInfo[])ar.result);
} else if (msg.what == EVENT_GET_CALL_WAITING_DONE) {
ssInfos = handleCwQueryResult((ImsSsInfo[])ar.result);
}
}
sendResponse((Message) ar.userObj, ssInfos, ar.exception);
break;
case EVENT_SET_CALL_BARRING_DONE:
case EVENT_SET_CALL_WAITING_DONE:
sendResponse((Message) ar.userObj, null, ar.exception);
break;
default:
super.handleMessage(msg);
break;
}
}
/**
* Listen to the IMS ECBM state change
*/
ImsEcbmStateListener mImsEcbmStateListener =
new ImsEcbmStateListener() {
@Override
public void onECBMEntered() {
if (DBG) Rlog.d(LOG_TAG, "onECBMEntered");
handleEnterEmergencyCallbackMode();
}
@Override
public void onECBMExited() {
if (DBG) Rlog.d(LOG_TAG, "onECBMExited");
handleExitEmergencyCallbackMode();
}
};
public boolean isInEmergencyCall() {
return mCT.isInEmergencyCall();
}
public boolean isInEcm() {
return mIsPhoneInEcmState;
}
void sendEmergencyCallbackModeChange() {
// Send an Intent
Intent intent = new Intent(TelephonyIntents.ACTION_EMERGENCY_CALLBACK_MODE_CHANGED);
intent.putExtra(PhoneConstants.PHONE_IN_ECM_STATE, mIsPhoneInEcmState);
SubscriptionManager.putPhoneIdAndSubIdExtra(intent, getPhoneId());
ActivityManagerNative.broadcastStickyIntent(intent, null, UserHandle.USER_ALL);
if (DBG) Rlog.d(LOG_TAG, "sendEmergencyCallbackModeChange");
}
@Override
public void exitEmergencyCallbackMode() {
if (mWakeLock.isHeld()) {
mWakeLock.release();
}
if (DBG) Rlog.d(LOG_TAG, "exitEmergencyCallbackMode()");
// Send a message which will invoke handleExitEmergencyCallbackMode
ImsEcbm ecbm;
try {
ecbm = mCT.getEcbmInterface();
ecbm.exitEmergencyCallbackMode();
} catch (ImsException e) {
e.printStackTrace();
}
}
private void handleEnterEmergencyCallbackMode() {
if (DBG) {
Rlog.d(LOG_TAG, "handleEnterEmergencyCallbackMode,mIsPhoneInEcmState= "
+ mIsPhoneInEcmState);
}
// if phone is not in Ecm mode, and it's changed to Ecm mode
if (mIsPhoneInEcmState == false) {
mIsPhoneInEcmState = true;
// notify change
sendEmergencyCallbackModeChange();
setSystemProperty(TelephonyProperties.PROPERTY_INECM_MODE, "true");
// Post this runnable so we will automatically exit
// if no one invokes exitEmergencyCallbackMode() directly.
long delayInMillis = SystemProperties.getLong(
TelephonyProperties.PROPERTY_ECM_EXIT_TIMER, DEFAULT_ECM_EXIT_TIMER_VALUE);
postDelayed(mExitEcmRunnable, delayInMillis);
// We don't want to go to sleep while in Ecm
mWakeLock.acquire();
}
}
private void handleExitEmergencyCallbackMode() {
if (DBG) {
Rlog.d(LOG_TAG, "handleExitEmergencyCallbackMode: mIsPhoneInEcmState = "
+ mIsPhoneInEcmState);
}
// Remove pending exit Ecm runnable, if any
removeCallbacks(mExitEcmRunnable);
if (mEcmExitRespRegistrant != null) {
mEcmExitRespRegistrant.notifyResult(Boolean.TRUE);
}
if (mIsPhoneInEcmState) {
mIsPhoneInEcmState = false;
setSystemProperty(TelephonyProperties.PROPERTY_INECM_MODE, "false");
}
// send an Intent
sendEmergencyCallbackModeChange();
}
/**
* Handle to cancel or restart Ecm timer in emergency call back mode if action is
* CANCEL_ECM_TIMER, cancel Ecm timer and notify apps the timer is canceled; otherwise, restart
* Ecm timer and notify apps the timer is restarted.
*/
void handleTimerInEmergencyCallbackMode(int action) {
switch (action) {
case CANCEL_ECM_TIMER:
removeCallbacks(mExitEcmRunnable);
if (mDefaultPhone.getPhoneType() == PhoneConstants.PHONE_TYPE_GSM) {
((GSMPhone) mDefaultPhone).notifyEcbmTimerReset(Boolean.TRUE);
} else { // Should be CDMA - also go here by default
((CDMAPhone) mDefaultPhone).notifyEcbmTimerReset(Boolean.TRUE);
}
break;
case RESTART_ECM_TIMER:
long delayInMillis = SystemProperties.getLong(
TelephonyProperties.PROPERTY_ECM_EXIT_TIMER, DEFAULT_ECM_EXIT_TIMER_VALUE);
postDelayed(mExitEcmRunnable, delayInMillis);
if (mDefaultPhone.getPhoneType() == PhoneConstants.PHONE_TYPE_GSM) {
((GSMPhone) mDefaultPhone).notifyEcbmTimerReset(Boolean.FALSE);
} else { // Should be CDMA - also go here by default
((CDMAPhone) mDefaultPhone).notifyEcbmTimerReset(Boolean.FALSE);
}
break;
default:
Rlog.e(LOG_TAG, "handleTimerInEmergencyCallbackMode, unsupported action " + action);
}
}
public void setOnEcbModeExitResponse(Handler h, int what, Object obj) {
mEcmExitRespRegistrant = new Registrant(h, what, obj);
}
public void unsetOnEcbModeExitResponse(Handler h) {
mEcmExitRespRegistrant.clear();
}
public boolean isVolteEnabled() {
return mCT.isVolteEnabled();
}
public boolean isVtEnabled() {
return mCT.isVtEnabled();
}
public Phone getDefaultPhone() {
return mDefaultPhone;
}
public boolean isImsRegistered() {
return mImsRegistered;
}
public void setImsRegistered(boolean value) {
mImsRegistered = value;
}
public void callEndCleanupHandOverCallIfAny() {
mCT.callEndCleanupHandOverCallIfAny();
}
}
|
