/*
* 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.test;
import android.os.AsyncResult;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.Looper;
import android.os.Message;
import android.os.Parcel;
import android.os.Registrant;
import android.os.SystemClock;
import android.service.carrier.CarrierIdentifier;
import android.telephony.CellInfo;
import android.telephony.CellInfoGsm;
import android.telephony.Rlog;
import android.telephony.ServiceState;
import android.telephony.SignalStrength;
import android.telephony.IccOpenLogicalChannelResponse;
import com.android.internal.annotations.VisibleForTesting;
import com.android.internal.telephony.BaseCommands;
import com.android.internal.telephony.CommandException;
import com.android.internal.telephony.CommandsInterface;
import com.android.internal.telephony.PhoneConstants;
import com.android.internal.telephony.SmsResponse;
import com.android.internal.telephony.RadioCapability;
import com.android.internal.telephony.cdma.CdmaSmsBroadcastConfigInfo;
import com.android.internal.telephony.dataconnection.DataCallResponse;
import com.android.internal.telephony.dataconnection.DataProfile;
import com.android.internal.telephony.Phone;
import com.android.internal.telephony.UUSInfo;
import com.android.internal.telephony.CallFailCause;
import com.android.internal.telephony.gsm.SmsBroadcastConfigInfo;
import com.android.internal.telephony.gsm.SuppServiceNotification;
import com.android.internal.telephony.LastCallFailCause;
import com.android.internal.telephony.uicc.IccCardStatus;
import com.android.internal.telephony.uicc.IccIoResult;
import java.util.ArrayList;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
public class SimulatedCommands extends BaseCommands
implements CommandsInterface, SimulatedRadioControl {
private final static String LOG_TAG = "SimulatedCommands";
private enum SimLockState {
NONE,
REQUIRE_PIN,
REQUIRE_PUK,
SIM_PERM_LOCKED
}
private enum SimFdnState {
NONE,
REQUIRE_PIN2,
REQUIRE_PUK2,
SIM_PERM_LOCKED
}
private final static SimLockState INITIAL_LOCK_STATE = SimLockState.NONE;
public final static String DEFAULT_SIM_PIN_CODE = "1234";
private final static String SIM_PUK_CODE = "12345678";
private final static SimFdnState INITIAL_FDN_STATE = SimFdnState.NONE;
public final static String DEFAULT_SIM_PIN2_CODE = "5678";
private final static String SIM_PUK2_CODE = "87654321";
public final static String FAKE_LONG_NAME = "Fake long name";
public final static String FAKE_SHORT_NAME = "Fake short name";
public final static String FAKE_MCC_MNC = "310260";
public final static String FAKE_IMEI = "012345678901234";
public final static String FAKE_IMEISV = "99";
public final static String FAKE_ESN = "1234";
public final static String FAKE_MEID = "1234";
public final static int DEFAULT_PIN1_ATTEMPT = 5;
public final static int DEFAULT_PIN2_ATTEMPT = 5;
private String mImei;
private String mImeiSv;
//***** Instance Variables
SimulatedGsmCallState simulatedCallState;
HandlerThread mHandlerThread;
SimLockState mSimLockedState;
boolean mSimLockEnabled;
int mPinUnlockAttempts;
int mPukUnlockAttempts;
String mPinCode;
int mPin1attemptsRemaining = DEFAULT_PIN1_ATTEMPT;
SimFdnState mSimFdnEnabledState;
boolean mSimFdnEnabled;
int mPin2UnlockAttempts;
int mPuk2UnlockAttempts;
int mNetworkType;
String mPin2Code;
boolean mSsnNotifyOn = false;
private int mVoiceRegState = ServiceState.RIL_REG_STATE_HOME;
private int mVoiceRadioTech = ServiceState.RIL_RADIO_TECHNOLOGY_UMTS;
private int mDataRegState = ServiceState.RIL_REG_STATE_HOME;
private int mDataRadioTech = ServiceState.RIL_RADIO_TECHNOLOGY_UMTS;
private SignalStrength mSignalStrength;
private List<CellInfo> mCellInfoList;
private int[] mImsRegState;
private IccCardStatus mIccCardStatus;
private IccIoResult mIccIoResultForApduLogicalChannel;
private int mChannelId = IccOpenLogicalChannelResponse.INVALID_CHANNEL;
int mPausedResponseCount;
ArrayList<Message> mPausedResponses = new ArrayList<Message>();
int mNextCallFailCause = CallFailCause.NORMAL_CLEARING;
private boolean mDcSuccess = true;
private DataCallResponse mDcResponse;
//***** Constructor
public
SimulatedCommands() {
super(null); // Don't log statistics
mHandlerThread = new HandlerThread("SimulatedCommands");
mHandlerThread.start();
Looper looper = mHandlerThread.getLooper();
simulatedCallState = new SimulatedGsmCallState(looper);
setRadioState(RadioState.RADIO_ON);
mSimLockedState = INITIAL_LOCK_STATE;
mSimLockEnabled = (mSimLockedState != SimLockState.NONE);
mPinCode = DEFAULT_SIM_PIN_CODE;
mSimFdnEnabledState = INITIAL_FDN_STATE;
mSimFdnEnabled = (mSimFdnEnabledState != SimFdnState.NONE);
mPin2Code = DEFAULT_SIM_PIN2_CODE;
}
private void log(String str) {
Rlog.d(LOG_TAG, str);
}
//***** CommandsInterface implementation
@Override
public void getIccCardStatus(Message result) {
if(mIccCardStatus!=null) {
resultSuccess(result, mIccCardStatus);
} else {
resultFail(result, null, new RuntimeException("IccCardStatus not set"));
}
}
@Override
public void supplyIccPin(String pin, Message result) {
if (mSimLockedState != SimLockState.REQUIRE_PIN) {
Rlog.i(LOG_TAG, "[SimCmd] supplyIccPin: wrong state, state=" +
mSimLockedState);
CommandException ex = new CommandException(
CommandException.Error.PASSWORD_INCORRECT);
resultFail(result, null, ex);
return;
}
if (pin != null && pin.equals(mPinCode)) {
Rlog.i(LOG_TAG, "[SimCmd] supplyIccPin: success!");
mPinUnlockAttempts = 0;
mSimLockedState = SimLockState.NONE;
mIccStatusChangedRegistrants.notifyRegistrants();
resultSuccess(result, null);
return;
}
if (result != null) {
mPinUnlockAttempts ++;
Rlog.i(LOG_TAG, "[SimCmd] supplyIccPin: failed! attempt=" +
mPinUnlockAttempts);
if (mPinUnlockAttempts >= DEFAULT_PIN1_ATTEMPT) {
Rlog.i(LOG_TAG, "[SimCmd] supplyIccPin: set state to REQUIRE_PUK");
mSimLockedState = SimLockState.REQUIRE_PUK;
}
CommandException ex = new CommandException(
CommandException.Error.PASSWORD_INCORRECT);
resultFail(result, null, ex);
}
}
@Override
public void supplyIccPuk(String puk, String newPin, Message result) {
if (mSimLockedState != SimLockState.REQUIRE_PUK) {
Rlog.i(LOG_TAG, "[SimCmd] supplyIccPuk: wrong state, state=" +
mSimLockedState);
CommandException ex = new CommandException(
CommandException.Error.PASSWORD_INCORRECT);
resultFail(result, null, ex);
return;
}
if (puk != null && puk.equals(SIM_PUK_CODE)) {
Rlog.i(LOG_TAG, "[SimCmd] supplyIccPuk: success!");
mSimLockedState = SimLockState.NONE;
mPukUnlockAttempts = 0;
mIccStatusChangedRegistrants.notifyRegistrants();
resultSuccess(result, null);
return;
}
if (result != null) {
mPukUnlockAttempts ++;
Rlog.i(LOG_TAG, "[SimCmd] supplyIccPuk: failed! attempt=" +
mPukUnlockAttempts);
if (mPukUnlockAttempts >= 10) {
Rlog.i(LOG_TAG, "[SimCmd] supplyIccPuk: set state to SIM_PERM_LOCKED");
mSimLockedState = SimLockState.SIM_PERM_LOCKED;
}
CommandException ex = new CommandException(
CommandException.Error.PASSWORD_INCORRECT);
resultFail(result, null, ex);
}
}
@Override
public void supplyIccPin2(String pin2, Message result) {
if (mSimFdnEnabledState != SimFdnState.REQUIRE_PIN2) {
Rlog.i(LOG_TAG, "[SimCmd] supplyIccPin2: wrong state, state=" +
mSimFdnEnabledState);
CommandException ex = new CommandException(
CommandException.Error.PASSWORD_INCORRECT);
resultFail(result, null, ex);
return;
}
if (pin2 != null && pin2.equals(mPin2Code)) {
Rlog.i(LOG_TAG, "[SimCmd] supplyIccPin2: success!");
mPin2UnlockAttempts = 0;
mSimFdnEnabledState = SimFdnState.NONE;
resultSuccess(result, null);
return;
}
if (result != null) {
mPin2UnlockAttempts ++;
Rlog.i(LOG_TAG, "[SimCmd] supplyIccPin2: failed! attempt=" +
mPin2UnlockAttempts);
if (mPin2UnlockAttempts >= DEFAULT_PIN2_ATTEMPT) {
Rlog.i(LOG_TAG, "[SimCmd] supplyIccPin2: set state to REQUIRE_PUK2");
mSimFdnEnabledState = SimFdnState.REQUIRE_PUK2;
}
CommandException ex = new CommandException(
CommandException.Error.PASSWORD_INCORRECT);
resultFail(result, null, ex);
}
}
@Override
public void supplyIccPuk2(String puk2, String newPin2, Message result) {
if (mSimFdnEnabledState != SimFdnState.REQUIRE_PUK2) {
Rlog.i(LOG_TAG, "[SimCmd] supplyIccPuk2: wrong state, state=" +
mSimLockedState);
CommandException ex = new CommandException(
CommandException.Error.PASSWORD_INCORRECT);
resultFail(result, null, ex);
return;
}
if (puk2 != null && puk2.equals(SIM_PUK2_CODE)) {
Rlog.i(LOG_TAG, "[SimCmd] supplyIccPuk2: success!");
mSimFdnEnabledState = SimFdnState.NONE;
mPuk2UnlockAttempts = 0;
resultSuccess(result, null);
return;
}
if (result != null) {
mPuk2UnlockAttempts ++;
Rlog.i(LOG_TAG, "[SimCmd] supplyIccPuk2: failed! attempt=" +
mPuk2UnlockAttempts);
if (mPuk2UnlockAttempts >= 10) {
Rlog.i(LOG_TAG, "[SimCmd] supplyIccPuk2: set state to SIM_PERM_LOCKED");
mSimFdnEnabledState = SimFdnState.SIM_PERM_LOCKED;
}
CommandException ex = new CommandException(
CommandException.Error.PASSWORD_INCORRECT);
resultFail(result, null, ex);
}
}
@Override
public void changeIccPin(String oldPin, String newPin, Message result) {
if (oldPin != null && oldPin.equals(mPinCode)) {
mPinCode = newPin;
resultSuccess(result, null);
return;
}
Rlog.i(LOG_TAG, "[SimCmd] changeIccPin: pin failed!");
CommandException ex = new CommandException(
CommandException.Error.PASSWORD_INCORRECT);
resultFail(result, null, ex);
}
@Override
public void changeIccPin2(String oldPin2, String newPin2, Message result) {
if (oldPin2 != null && oldPin2.equals(mPin2Code)) {
mPin2Code = newPin2;
resultSuccess(result, null);
return;
}
Rlog.i(LOG_TAG, "[SimCmd] changeIccPin2: pin2 failed!");
CommandException ex = new CommandException(
CommandException.Error.PASSWORD_INCORRECT);
resultFail(result, null, ex);
}
@Override
public void
changeBarringPassword(String facility, String oldPwd, String newPwd, Message result) {
unimplemented(result);
}
@Override
public void
setSuppServiceNotifications(boolean enable, Message result) {
resultSuccess(result, null);
if (enable && mSsnNotifyOn) {
Rlog.w(LOG_TAG, "Supp Service Notifications already enabled!");
}
mSsnNotifyOn = enable;
}
@Override
public void queryFacilityLock(String facility, String pin,
int serviceClass, Message result) {
queryFacilityLockForApp(facility, pin, serviceClass, null, result);
}
@Override
public void queryFacilityLockForApp(String facility, String pin, int serviceClass,
String appId, Message result) {
if (facility != null && facility.equals(CommandsInterface.CB_FACILITY_BA_SIM)) {
if (result != null) {
int[] r = new int[1];
r[0] = (mSimLockEnabled ? 1 : 0);
Rlog.i(LOG_TAG, "[SimCmd] queryFacilityLock: SIM is "
+ (r[0] == 0 ? "unlocked" : "locked"));
resultSuccess(result, r);
}
return;
} else if (facility != null && facility.equals(CommandsInterface.CB_FACILITY_BA_FD)) {
if (result != null) {
int[] r = new int[1];
r[0] = (mSimFdnEnabled ? 1 : 0);
Rlog.i(LOG_TAG, "[SimCmd] queryFacilityLock: FDN is "
+ (r[0] == 0 ? "disabled" : "enabled"));
resultSuccess(result, r);
}
return;
}
unimplemented(result);
}
@Override
public void setFacilityLock(String facility, boolean lockEnabled, String pin, int serviceClass,
Message result) {
setFacilityLockForApp(facility, lockEnabled, pin, serviceClass, null, result);
}
@Override
public void setFacilityLockForApp(String facility, boolean lockEnabled,
String pin, int serviceClass, String appId,
Message result) {
if (facility != null &&
facility.equals(CommandsInterface.CB_FACILITY_BA_SIM)) {
if (pin != null && pin.equals(mPinCode)) {
Rlog.i(LOG_TAG, "[SimCmd] setFacilityLock: pin is valid");
mSimLockEnabled = lockEnabled;
resultSuccess(result, null);
return;
}
Rlog.i(LOG_TAG, "[SimCmd] setFacilityLock: pin failed!");
CommandException ex = new CommandException(
CommandException.Error.GENERIC_FAILURE);
resultFail(result, null, ex);
return;
} else if (facility != null &&
facility.equals(CommandsInterface.CB_FACILITY_BA_FD)) {
if (pin != null && pin.equals(mPin2Code)) {
Rlog.i(LOG_TAG, "[SimCmd] setFacilityLock: pin2 is valid");
mSimFdnEnabled = lockEnabled;
resultSuccess(result, null);
return;
}
Rlog.i(LOG_TAG, "[SimCmd] setFacilityLock: pin2 failed!");
CommandException ex = new CommandException(
CommandException.Error.GENERIC_FAILURE);
resultFail(result, null, ex);
return;
}
unimplemented(result);
}
@Override
public void supplyNetworkDepersonalization(String netpin, Message result) {
unimplemented(result);
}
/**
* returned message
* retMsg.obj = AsyncResult ar
* ar.exception carries exception on failure
* ar.userObject contains the original value of result.obj
* ar.result contains a List of DriverCall
* The ar.result List is sorted by DriverCall.index
*/
@Override
public void getCurrentCalls (Message result) {
SimulatedCommandsVerifier.getInstance().getCurrentCalls(result);
if ((mState == RadioState.RADIO_ON) && !isSimLocked()) {
//Rlog.i("GSM", "[SimCmds] getCurrentCalls");
resultSuccess(result, simulatedCallState.getDriverCalls());
} else {
//Rlog.i("GSM", "[SimCmds] getCurrentCalls: RADIO_OFF or SIM not ready!");
resultFail(result, null,
new CommandException(CommandException.Error.RADIO_NOT_AVAILABLE));
}
}
/**
* @deprecated
*/
@Deprecated
@Override
public void getPDPContextList(Message result) {
getDataCallList(result);
}
/**
* returned message
* retMsg.obj = AsyncResult ar
* ar.exception carries exception on failure
* ar.userObject contains the original value of result.obj
* ar.result contains a List of DataCallResponse
*/
@Override
public void getDataCallList(Message result) {
resultSuccess(result, new ArrayList<DataCallResponse>(0));
}
/**
* returned message
* retMsg.obj = AsyncResult ar
* ar.exception carries exception on failure
* ar.userObject contains the original value of result.obj
* ar.result is null on success and failure
*
* CLIR_DEFAULT == on "use subscription default value"
* CLIR_SUPPRESSION == on "CLIR suppression" (allow CLI presentation)
* CLIR_INVOCATION == on "CLIR invocation" (restrict CLI presentation)
*/
@Override
public void dial (String address, int clirMode, Message result) {
SimulatedCommandsVerifier.getInstance().dial(address, clirMode, result);
simulatedCallState.onDial(address);
resultSuccess(result, null);
}
/**
* returned message
* retMsg.obj = AsyncResult ar
* ar.exception carries exception on failure
* ar.userObject contains the original value of result.obj
* ar.result is null on success and failure
*
* CLIR_DEFAULT == on "use subscription default value"
* CLIR_SUPPRESSION == on "CLIR suppression" (allow CLI presentation)
* CLIR_INVOCATION == on "CLIR invocation" (restrict CLI presentation)
*/
@Override
public void dial(String address, int clirMode, UUSInfo uusInfo, Message result) {
SimulatedCommandsVerifier.getInstance().dial(address, clirMode, uusInfo, result);
simulatedCallState.onDial(address);
resultSuccess(result, null);
}
@Override
public void getIMSI(Message result) {
getIMSIForApp(null, result);
}
/**
* returned message
* retMsg.obj = AsyncResult ar
* ar.exception carries exception on failure
* ar.userObject contains the original value of result.obj
* ar.result is String containing IMSI on success
*/
@Override
public void getIMSIForApp(String aid, Message result) {
resultSuccess(result, "012345678901234");
}
public void setIMEI(String imei) {
mImei = imei;
}
/**
* returned message
* retMsg.obj = AsyncResult ar
* ar.exception carries exception on failure
* ar.userObject contains the original value of result.obj
* ar.result is String containing IMEI on success
*/
@Override
public void getIMEI(Message result) {
SimulatedCommandsVerifier.getInstance().getIMEI(result);
resultSuccess(result, mImei != null ? mImei : FAKE_IMEI);
}
public void setIMEISV(String imeisv) {
mImeiSv = imeisv;
}
/**
* returned message
* retMsg.obj = AsyncResult ar
* ar.exception carries exception on failure
* ar.userObject contains the original value of result.obj
* ar.result is String containing IMEISV on success
*/
@Override
public void getIMEISV(Message result) {
SimulatedCommandsVerifier.getInstance().getIMEISV(result);
resultSuccess(result, mImeiSv != null ? mImeiSv : FAKE_IMEISV);
}
/**
* Hang up one individual connection.
* returned message
* retMsg.obj = AsyncResult ar
* ar.exception carries exception on failure
* ar.userObject contains the original value of result.obj
* ar.result is null on success and failure
*
* 3GPP 22.030 6.5.5
* "Releases a specific active call X"
*/
@Override
public void hangupConnection (int gsmIndex, Message result) {
boolean success;
success = simulatedCallState.onChld('1', (char)('0'+gsmIndex));
if (!success){
Rlog.i("GSM", "[SimCmd] hangupConnection: resultFail");
resultFail(result, null, new RuntimeException("Hangup Error"));
} else {
Rlog.i("GSM", "[SimCmd] hangupConnection: resultSuccess");
resultSuccess(result, null);
}
}
/**
* 3GPP 22.030 6.5.5
* "Releases all held calls or sets User Determined User Busy (UDUB)
* for a waiting call."
* ar.exception carries exception on failure
* ar.userObject contains the original value of result.obj
* ar.result is null on success and failure
*/
@Override
public void hangupWaitingOrBackground (Message result) {
boolean success;
success = simulatedCallState.onChld('0', '\0');
if (!success){
resultFail(result, null, new RuntimeException("Hangup Error"));
} else {
resultSuccess(result, null);
}
}
/**
* 3GPP 22.030 6.5.5
* "Releases all active calls (if any exist) and accepts
* the other (held or waiting) call."
*
* ar.exception carries exception on failure
* ar.userObject contains the original value of result.obj
* ar.result is null on success and failure
*/
@Override
public void hangupForegroundResumeBackground (Message result) {
boolean success;
success = simulatedCallState.onChld('1', '\0');
if (!success){
resultFail(result, null, new RuntimeException("Hangup Error"));
} else {
resultSuccess(result, null);
}
}
/**
* 3GPP 22.030 6.5.5
* "Places all active calls (if any exist) on hold and accepts
* the other (held or waiting) call."
*
* ar.exception carries exception on failure
* ar.userObject contains the original value of result.obj
* ar.result is null on success and failure
*/
@Override
public void switchWaitingOrHoldingAndActive (Message result) {
boolean success;
success = simulatedCallState.onChld('2', '\0');
if (!success){
resultFail(result, null, new RuntimeException("Hangup Error"));
} else {
resultSuccess(result, null);
}
}
/**
* 3GPP 22.030 6.5.5
* "Adds a held call to the conversation"
*
* ar.exception carries exception on failure
* ar.userObject contains the original value of result.obj
* ar.result is null on success and failure
*/
@Override
public void conference (Message result) {
boolean success;
success = simulatedCallState.onChld('3', '\0');
if (!success){
resultFail(result, null, new RuntimeException("Hangup Error"));
} else {
resultSuccess(result, null);
}
}
/**
* 3GPP 22.030 6.5.5
* "Connects the two calls and disconnects the subscriber from both calls"
*
* ar.exception carries exception on failure
* ar.userObject contains the original value of result.obj
* ar.result is null on success and failure
*/
@Override
public void explicitCallTransfer (Message result) {
boolean success;
success = simulatedCallState.onChld('4', '\0');
if (!success){
resultFail(result, null, new RuntimeException("Hangup Error"));
} else {
resultSuccess(result, null);
}
}
/**
* 3GPP 22.030 6.5.5
* "Places all active calls on hold except call X with which
* communication shall be supported."
*/
@Override
public void separateConnection (int gsmIndex, Message result) {
boolean success;
char ch = (char)(gsmIndex + '0');
success = simulatedCallState.onChld('2', ch);
if (!success){
resultFail(result, null, new RuntimeException("Hangup Error"));
} else {
resultSuccess(result, null);
}
}
/**
*
* ar.exception carries exception on failure
* ar.userObject contains the original value of result.obj
* ar.result is null on success and failure
*/
@Override
public void acceptCall (Message result) {
boolean success;
SimulatedCommandsVerifier.getInstance().acceptCall(result);
success = simulatedCallState.onAnswer();
if (!success){
resultFail(result, null, new RuntimeException("Hangup Error"));
} else {
resultSuccess(result, null);
}
}
/**
* also known as UDUB
* ar.exception carries exception on failure
* ar.userObject contains the original value of result.obj
* ar.result is null on success and failure
*/
@Override
public void rejectCall (Message result) {
boolean success;
success = simulatedCallState.onChld('0', '\0');
if (!success){
resultFail(result, null, new RuntimeException("Hangup Error"));
} else {
resultSuccess(result, null);
}
}
/**
* cause code returned as Integer in Message.obj.response
* Returns integer cause code defined in TS 24.008
* Annex H or closest approximation.
* Most significant codes:
* - Any defined in 22.001 F.4 (for generating busy/congestion)
* - Cause 68: ACM >= ACMMax
*/
@Override
public void getLastCallFailCause (Message result) {
LastCallFailCause mFailCause = new LastCallFailCause();
mFailCause.causeCode = mNextCallFailCause;
resultSuccess(result, mFailCause);
}
/**
* @deprecated
*/
@Deprecated
@Override
public void getLastPdpFailCause (Message result) {
unimplemented(result);
}
@Override
public void getLastDataCallFailCause(Message result) {
//
unimplemented(result);
}
@Override
public void setMute (boolean enableMute, Message result) {unimplemented(result);}
@Override
public void getMute (Message result) {unimplemented(result);}
public void setSignalStrength(SignalStrength signalStrength) {
mSignalStrength = signalStrength;
}
@Override
public void getSignalStrength (Message result) {
if (mSignalStrength == null) {
mSignalStrength = new SignalStrength(
20, // gsmSignalStrength
0, // gsmBitErrorRate
-1, // cdmaDbm
-1, // cdmaEcio
-1, // evdoDbm
-1, // evdoEcio
-1, // evdoSnr
99, // lteSignalStrength
SignalStrength.INVALID, // lteRsrp
SignalStrength.INVALID, // lteRsrq
SignalStrength.INVALID, // lteRssnr
SignalStrength.INVALID, // lteCqi
SignalStrength.INVALID, // tdScdmaRscp
true // gsmFlag
);
}
resultSuccess(result, mSignalStrength);
}
/**
* Assign a specified band for RF configuration.
*
* @param bandMode one of BM_*_BAND
* @param result is callback message
*/
@Override
public void setBandMode (int bandMode, Message result) {
resultSuccess(result, null);
}
/**
* Query the list of band mode supported by RF.
*
* @param result is callback message
* ((AsyncResult)response.obj).result is an int[] where int[0] is
* the size of the array and the rest of each element representing
* one available BM_*_BAND
*/
@Override
public void queryAvailableBandMode (Message result) {
int ret[] = new int [4];
ret[0] = 4;
ret[1] = Phone.BM_US_BAND;
ret[2] = Phone.BM_JPN_BAND;
ret[3] = Phone.BM_AUS_BAND;
resultSuccess(result, ret);
}
/**
* {@inheritDoc}
*/
@Override
public void sendTerminalResponse(String contents, Message response) {
resultSuccess(response, null);
}
/**
* {@inheritDoc}
*/
@Override
public void sendEnvelope(String contents, Message response) {
resultSuccess(response, null);
}
/**
* {@inheritDoc}
*/
@Override
public void sendEnvelopeWithStatus(String contents, Message response) {
resultSuccess(response, null);
}
/**
* {@inheritDoc}
*/
@Override
public void handleCallSetupRequestFromSim(
boolean accept, Message response) {
resultSuccess(response, null);
}
public void setVoiceRadioTech(int voiceRadioTech) {
mVoiceRadioTech = voiceRadioTech;
}
public void setVoiceRegState(int voiceRegState) {
mVoiceRegState = voiceRegState;
}
/**
* response.obj.result is an String[14]
* See ril.h for details
*
* Please note that registration state 4 ("unknown") is treated
* as "out of service" above
*/
@Override
public void getVoiceRegistrationState(Message result) {
mGetVoiceRegistrationStateCallCount.incrementAndGet();
String ret[] = new String[14];
ret[0] = Integer.toString(mVoiceRegState);
ret[3] = Integer.toString(mVoiceRadioTech);
resultSuccess(result, ret);
}
private final AtomicInteger mGetVoiceRegistrationStateCallCount = new AtomicInteger(0);
@VisibleForTesting
public int getGetVoiceRegistrationStateCallCount() {
return mGetVoiceRegistrationStateCallCount.get();
}
public void setDataRadioTech(int radioTech) {
mDataRadioTech = radioTech;
}
public void setDataRegState(int dataRegState) {
mDataRegState = dataRegState;
}
@Override
public void getDataRegistrationState (Message result) {
mGetDataRegistrationStateCallCount.incrementAndGet();
String ret[] = new String[11];
ret[0] = Integer.toString(mDataRegState);
ret[3] = Integer.toString(mDataRadioTech);
resultSuccess(result, ret);
}
private final AtomicInteger mGetDataRegistrationStateCallCount = new AtomicInteger(0);
@VisibleForTesting
public int getGetDataRegistrationStateCallCount() {
return mGetDataRegistrationStateCallCount.get();
}
/**
* response.obj.result is a String[3]
* response.obj.result[0] is long alpha or null if unregistered
* response.obj.result[1] is short alpha or null if unregistered
* response.obj.result[2] is numeric or null if unregistered
*/
@Override
public void getOperator(Message result) {
mGetOperatorCallCount.incrementAndGet();
String[] ret = new String[3];
ret[0] = FAKE_LONG_NAME;
ret[1] = FAKE_SHORT_NAME;
ret[2] = FAKE_MCC_MNC;
resultSuccess(result, ret);
}
private final AtomicInteger mGetOperatorCallCount = new AtomicInteger(0);
@VisibleForTesting
public int getGetOperatorCallCount() {
final int count = mGetOperatorCallCount.get();
return mGetOperatorCallCount.get();
}
/**
* ar.exception carries exception on failure
* ar.userObject contains the original value of result.obj
* ar.result is null on success and failure
*/
@Override
public void sendDtmf(char c, Message result) {
resultSuccess(result, null);
}
/**
* ar.exception carries exception on failure
* ar.userObject contains the original value of result.obj
* ar.result is null on success and failure
*/
@Override
public void startDtmf(char c, Message result) {
resultSuccess(result, null);
}
/**
* ar.exception carries exception on failure
* ar.userObject contains the original value of result.obj
* ar.result is null on success and failure
*/
@Override
public void stopDtmf(Message result) {
resultSuccess(result, null);
}
/**
* ar.exception carries exception on failure
* ar.userObject contains the original value of result.obj
* ar.result is null on success and failure
*/
@Override
public void sendBurstDtmf(String dtmfString, int on, int off, Message result) {
SimulatedCommandsVerifier.getInstance().sendBurstDtmf(dtmfString, on, off, result);
resultSuccess(result, null);
}
/**
* smscPDU is smsc address in PDU form GSM BCD format prefixed
* by a length byte (as expected by TS 27.005) or NULL for default SMSC
* pdu is SMS in PDU format as an ASCII hex string
* less the SMSC address
*/
@Override
public void sendSMS (String smscPDU, String pdu, Message result) {
SimulatedCommandsVerifier.getInstance().sendSMS(smscPDU, pdu, result);
resultSuccess(result, new SmsResponse(0 /*messageRef*/, null, 0));
}
/**
* Send an SMS message, Identical to sendSMS,
* except that more messages are expected to be sent soon
* smscPDU is smsc address in PDU form GSM BCD format prefixed
* by a length byte (as expected by TS 27.005) or NULL for default SMSC
* pdu is SMS in PDU format as an ASCII hex string
* less the SMSC address
*/
@Override
public void sendSMSExpectMore (String smscPDU, String pdu, Message result) {
unimplemented(result);
}
@Override
public void deleteSmsOnSim(int index, Message response) {
Rlog.d(LOG_TAG, "Delete message at index " + index);
unimplemented(response);
}
@Override
public void deleteSmsOnRuim(int index, Message response) {
Rlog.d(LOG_TAG, "Delete RUIM message at index " + index);
unimplemented(response);
}
@Override
public void writeSmsToSim(int status, String smsc, String pdu, Message response) {
Rlog.d(LOG_TAG, "Write SMS to SIM with status " + status);
unimplemented(response);
}
@Override
public void writeSmsToRuim(int status, String pdu, Message response) {
Rlog.d(LOG_TAG, "Write SMS to RUIM with status " + status);
unimplemented(response);
}
public void setDataCallResponse(final boolean success, final DataCallResponse dcResponse) {
mDcResponse = dcResponse;
mDcSuccess = success;
}
public void triggerNITZupdate(String NITZStr) {
if (NITZStr != null) {
mNITZTimeRegistrant.notifyRegistrant(new AsyncResult (null, new Object[]{NITZStr,
SystemClock.elapsedRealtime()}, null));
}
}
@Override
public void setupDataCall(int radioTechnology, int profile,
String apn, String user, String password, int authType,
String protocol, Message result) {
SimulatedCommandsVerifier.getInstance().setupDataCall(radioTechnology, profile, apn, user,
password, authType, protocol, result);
if (mDcResponse == null) {
mDcResponse = new DataCallResponse();
mDcResponse.version = 11;
mDcResponse.status = 0;
mDcResponse.suggestedRetryTime = -1;
mDcResponse.cid = 1;
mDcResponse.active = 2;
mDcResponse.type = "IP";
mDcResponse.ifname = "rmnet_data7";
mDcResponse.mtu = 1440;
mDcResponse.addresses = new String[]{"12.34.56.78"};
mDcResponse.dnses = new String[]{"98.76.54.32"};
mDcResponse.gateways = new String[]{"11.22.33.44"};
mDcResponse.pcscf = new String[]{};
}
if (mDcSuccess) {
resultSuccess(result, mDcResponse);
} else {
resultFail(result, mDcResponse, new RuntimeException("Setup data call failed!"));
}
}
@Override
public void deactivateDataCall(int cid, int reason, Message result) {
SimulatedCommandsVerifier.getInstance().deactivateDataCall(cid, reason, result);
resultSuccess(result, null);
}
@Override
public void setPreferredNetworkType(int networkType , Message result) {
SimulatedCommandsVerifier.getInstance().setPreferredNetworkType(networkType, result);
mNetworkType = networkType;
resultSuccess(result, null);
}
@Override
public void getPreferredNetworkType(Message result) {
SimulatedCommandsVerifier.getInstance().getPreferredNetworkType(result);
int ret[] = new int[1];
ret[0] = mNetworkType;
resultSuccess(result, ret);
}
@Override
public void getNeighboringCids(Message result) {
int ret[] = new int[7];
ret[0] = 6;
for (int i = 1; i<7; i++) {
ret[i] = i;
}
resultSuccess(result, ret);
}
@Override
public void setLocationUpdates(boolean enable, Message response) {
SimulatedCommandsVerifier.getInstance().setLocationUpdates(enable, response);
resultSuccess(response, null);
}
@Override
public void getSmscAddress(Message result) {
unimplemented(result);
}
@Override
public void setSmscAddress(String address, Message result) {
unimplemented(result);
}
@Override
public void reportSmsMemoryStatus(boolean available, Message result) {
resultSuccess(result, null);
SimulatedCommandsVerifier.getInstance().reportSmsMemoryStatus(available, result);
}
@Override
public void reportStkServiceIsRunning(Message result) {
resultSuccess(result, null);
}
@Override
public void getCdmaSubscriptionSource(Message result) {
unimplemented(result);
}
private boolean isSimLocked() {
if (mSimLockedState != SimLockState.NONE) {
return true;
}
return false;
}
@Override
public void setRadioPower(boolean on, Message result) {
if(on) {
setRadioState(RadioState.RADIO_ON);
} else {
setRadioState(RadioState.RADIO_OFF);
}
}
@Override
public void acknowledgeLastIncomingGsmSms(boolean success, int cause, Message result) {
unimplemented(result);
SimulatedCommandsVerifier.getInstance().
acknowledgeLastIncomingGsmSms(success, cause, result);
}
@Override
public void acknowledgeLastIncomingCdmaSms(boolean success, int cause, Message result) {
unimplemented(result);
}
@Override
public void acknowledgeIncomingGsmSmsWithPdu(boolean success, String ackPdu,
Message result) {
unimplemented(result);
}
@Override
public void iccIO(int command, int fileid, String path, int p1, int p2, int p3, String data,
String pin2, Message response) {
iccIOForApp(command, fileid, path, p1, p2, p3, data, pin2, null, response);
}
/**
* parameters equivalent to 27.007 AT+CRSM command
* response.obj will be an AsyncResult
* response.obj.userObj will be a SimIoResult on success
*/
@Override
public void iccIOForApp (int command, int fileid, String path, int p1, int p2,
int p3, String data, String pin2, String aid, Message result) {
unimplemented(result);
}
/**
* (AsyncResult)response.obj).result is an int[] with element [0] set to
* 1 for "CLIP is provisioned", and 0 for "CLIP is not provisioned".
*
* @param response is callback message
*/
@Override
public void queryCLIP(Message response) { unimplemented(response); }
/**
* response.obj will be a an int[2]
*
* response.obj[0] will be TS 27.007 +CLIR parameter 'n'
* 0 presentation indicator is used according to the subscription of the CLIR service
* 1 CLIR invocation
* 2 CLIR suppression
*
* response.obj[1] will be TS 27.007 +CLIR parameter 'm'
* 0 CLIR not provisioned
* 1 CLIR provisioned in permanent mode
* 2 unknown (e.g. no network, etc.)
* 3 CLIR temporary mode presentation restricted
* 4 CLIR temporary mode presentation allowed
*/
@Override
public void getCLIR(Message result) {unimplemented(result);}
/**
* clirMode is one of the CLIR_* constants above
*
* response.obj is null
*/
@Override
public void setCLIR(int clirMode, Message result) {unimplemented(result);}
/**
* (AsyncResult)response.obj).result is an int[] with element [0] set to
* 0 for disabled, 1 for enabled.
*
* @param serviceClass is a sum of SERVICE_CLASS_*
* @param response is callback message
*/
@Override
public void queryCallWaiting(int serviceClass, Message response) {
unimplemented(response);
}
/**
* @param enable is true to enable, false to disable
* @param serviceClass is a sum of SERVICE_CLASS_*
* @param response is callback message
*/
@Override
public void setCallWaiting(boolean enable, int serviceClass,
Message response) {
unimplemented(response);
}
/**
* @param action is one of CF_ACTION_*
* @param cfReason is one of CF_REASON_*
* @param serviceClass is a sum of SERVICE_CLASSS_*
*/
@Override
public void setCallForward(int action, int cfReason, int serviceClass,
String number, int timeSeconds, Message result) {
SimulatedCommandsVerifier.getInstance().setCallForward(action, cfReason, serviceClass,
number, timeSeconds, result);
resultSuccess(result, null);
}
/**
* cfReason is one of CF_REASON_*
*
* ((AsyncResult)response.obj).result will be an array of
* CallForwardInfo's
*
* An array of length 0 means "disabled for all codes"
*/
@Override
public void queryCallForwardStatus(int cfReason, int serviceClass,
String number, Message result) {
SimulatedCommandsVerifier.getInstance().queryCallForwardStatus(cfReason, serviceClass,
number, result);
resultSuccess(result, null);
}
@Override
public void setNetworkSelectionModeAutomatic(Message result) {unimplemented(result);}
@Override
public void exitEmergencyCallbackMode(Message result) {unimplemented(result);}
@Override
public void setNetworkSelectionModeManual(
String operatorNumeric, Message result) {unimplemented(result);}
/**
* Queries whether the current network selection mode is automatic
* or manual
*
* ((AsyncResult)response.obj).result is an int[] with element [0] being
* a 0 for automatic selection and a 1 for manual selection
*/
@Override
public void getNetworkSelectionMode(Message result) {
SimulatedCommandsVerifier.getInstance().getNetworkSelectionMode(result);
getNetworkSelectionModeCallCount.incrementAndGet();
int ret[] = new int[1];
ret[0] = 0;
resultSuccess(result, ret);
}
private final AtomicInteger getNetworkSelectionModeCallCount = new AtomicInteger(0);
@VisibleForTesting
public int getGetNetworkSelectionModeCallCount() {
return getNetworkSelectionModeCallCount.get();
}
/**
* Queries the currently available networks
*
* ((AsyncResult)response.obj).result is a List of NetworkInfo objects
*/
@Override
public void getAvailableNetworks(Message result) {unimplemented(result);}
@Override
public void getBasebandVersion (Message result) {
SimulatedCommandsVerifier.getInstance().getBasebandVersion(result);
resultSuccess(result, "SimulatedCommands");
}
/**
* Simulates an Stk Call Control Alpha message
* @param alphaString Alpha string to send.
*/
public void triggerIncomingStkCcAlpha(String alphaString) {
if (mCatCcAlphaRegistrant != null) {
mCatCcAlphaRegistrant.notifyResult(alphaString);
}
}
public void sendStkCcAplha(String alphaString) {
triggerIncomingStkCcAlpha(alphaString);
}
/**
* Simulates an incoming USSD message
* @param statusCode Status code string. See <code>setOnUSSD</code>
* in CommandsInterface.java
* @param message Message text to send or null if none
*/
@Override
public void triggerIncomingUssd(String statusCode, String message) {
if (mUSSDRegistrant != null) {
String[] result = {statusCode, message};
mUSSDRegistrant.notifyResult(result);
}
}
@Override
public void sendUSSD (String ussdString, Message result) {
// We simulate this particular sequence
if (ussdString.equals("#646#")) {
resultSuccess(result, null);
// 0 == USSD-Notify
triggerIncomingUssd("0", "You have NNN minutes remaining.");
} else {
resultSuccess(result, null);
triggerIncomingUssd("0", "All Done");
}
}
// inherited javadoc suffices
@Override
public void cancelPendingUssd (Message response) {
resultSuccess(response, null);
}
@Override
public void resetRadio(Message result) {
unimplemented(result);
}
@Override
public void invokeOemRilRequestRaw(byte[] data, Message response) {
// Just echo back data
if (response != null) {
AsyncResult.forMessage(response).result = data;
response.sendToTarget();
}
}
@Override
public void invokeOemRilRequestStrings(String[] strings, Message response) {
// Just echo back data
if (response != null) {
AsyncResult.forMessage(response).result = strings;
response.sendToTarget();
}
}
//***** SimulatedRadioControl
/** Start the simulated phone ringing */
@Override
public void
triggerRing(String number) {
simulatedCallState.triggerRing(number);
mCallStateRegistrants.notifyRegistrants();
}
@Override
public void
progressConnectingCallState() {
simulatedCallState.progressConnectingCallState();
mCallStateRegistrants.notifyRegistrants();
}
/** If a call is DIALING or ALERTING, progress it all the way to ACTIVE */
@Override
public void
progressConnectingToActive() {
simulatedCallState.progressConnectingToActive();
mCallStateRegistrants.notifyRegistrants();
}
/** automatically progress mobile originated calls to ACTIVE.
* default to true
*/
@Override
public void
setAutoProgressConnectingCall(boolean b) {
simulatedCallState.setAutoProgressConnectingCall(b);
}
@Override
public void
setNextDialFailImmediately(boolean b) {
simulatedCallState.setNextDialFailImmediately(b);
}
@Override
public void
setNextCallFailCause(int gsmCause) {
mNextCallFailCause = gsmCause;
}
@Override
public void
triggerHangupForeground() {
simulatedCallState.triggerHangupForeground();
mCallStateRegistrants.notifyRegistrants();
}
/** hangup holding calls */
@Override
public void
triggerHangupBackground() {
simulatedCallState.triggerHangupBackground();
mCallStateRegistrants.notifyRegistrants();
}
@Override
public void triggerSsn(int type, int code) {
SuppServiceNotification not = new SuppServiceNotification();
not.notificationType = type;
not.code = code;
mSsnRegistrant.notifyRegistrant(new AsyncResult(null, not, null));
}
@Override
public void
shutdown() {
setRadioState(RadioState.RADIO_UNAVAILABLE);
Looper looper = mHandlerThread.getLooper();
if (looper != null) {
looper.quit();
}
}
/** hangup all */
@Override
public void
triggerHangupAll() {
simulatedCallState.triggerHangupAll();
mCallStateRegistrants.notifyRegistrants();
}
@Override
public void
triggerIncomingSMS(String message) {
//TODO
}
@Override
public void
pauseResponses() {
mPausedResponseCount++;
}
@Override
public void
resumeResponses() {
mPausedResponseCount--;
if (mPausedResponseCount == 0) {
for (int i = 0, s = mPausedResponses.size(); i < s ; i++) {
mPausedResponses.get(i).sendToTarget();
}
mPausedResponses.clear();
} else {
Rlog.e("GSM", "SimulatedCommands.resumeResponses < 0");
}
}
//***** Private Methods
private void unimplemented(Message result) {
if (result != null) {
AsyncResult.forMessage(result).exception
= new RuntimeException("Unimplemented");
if (mPausedResponseCount > 0) {
mPausedResponses.add(result);
} else {
result.sendToTarget();
}
}
}
private void resultSuccess(Message result, Object ret) {
if (result != null) {
AsyncResult.forMessage(result).result = ret;
if (mPausedResponseCount > 0) {
mPausedResponses.add(result);
} else {
result.sendToTarget();
}
}
}
private void resultFail(Message result, Object ret, Throwable tr) {
if (result != null) {
AsyncResult.forMessage(result, ret, tr);
if (mPausedResponseCount > 0) {
mPausedResponses.add(result);
} else {
result.sendToTarget();
}
}
}
// ***** Methods for CDMA support
@Override
public void
getDeviceIdentity(Message response) {
SimulatedCommandsVerifier.getInstance().getDeviceIdentity(response);
resultSuccess(response, new String[] {FAKE_IMEI, FAKE_IMEISV, FAKE_ESN, FAKE_MEID});
}
@Override
public void
getCDMASubscription(Message result) {
String ret[] = new String[5];
ret[0] = "123";
ret[1] = "456";
ret[2] = "789";
ret[3] = "234";
ret[4] = "345";
resultSuccess(result, ret);
}
@Override
public void
setCdmaSubscriptionSource(int cdmaSubscriptionType, Message response) {
unimplemented(response);
}
@Override
public void queryCdmaRoamingPreference(Message response) {
unimplemented(response);
}
@Override
public void setCdmaRoamingPreference(int cdmaRoamingType, Message response) {
unimplemented(response);
}
@Override
public void
setPhoneType(int phoneType) {
}
@Override
public void getPreferredVoicePrivacy(Message result) {
unimplemented(result);
}
@Override
public void setPreferredVoicePrivacy(boolean enable, Message result) {
unimplemented(result);
}
/**
* Set the TTY mode
*
* @param ttyMode is one of the following:
* - {@link com.android.internal.telephony.Phone#TTY_MODE_OFF}
* - {@link com.android.internal.telephony.Phone#TTY_MODE_FULL}
* - {@link com.android.internal.telephony.Phone#TTY_MODE_HCO}
* - {@link com.android.internal.telephony.Phone#TTY_MODE_VCO}
* @param response is callback message
*/
@Override
public void setTTYMode(int ttyMode, Message response) {
Rlog.w(LOG_TAG, "Not implemented in SimulatedCommands");
unimplemented(response);
}
/**
* Query the TTY mode
* (AsyncResult)response.obj).result is an int[] with element [0] set to
* tty mode:
* - {@link com.android.internal.telephony.Phone#TTY_MODE_OFF}
* - {@link com.android.internal.telephony.Phone#TTY_MODE_FULL}
* - {@link com.android.internal.telephony.Phone#TTY_MODE_HCO}
* - {@link com.android.internal.telephony.Phone#TTY_MODE_VCO}
* @param response is callback message
*/
@Override
public void queryTTYMode(Message response) {
unimplemented(response);
}
/**
* {@inheritDoc}
*/
@Override
public void sendCDMAFeatureCode(String FeatureCode, Message response) {
unimplemented(response);
}
/**
* {@inheritDoc}
*/
@Override
public void sendCdmaSms(byte[] pdu, Message response){
SimulatedCommandsVerifier.getInstance().sendCdmaSms(pdu, response);
resultSuccess(response, null);
}
@Override
public void setCdmaBroadcastActivation(boolean activate, Message response) {
unimplemented(response);
}
@Override
public void getCdmaBroadcastConfig(Message response) {
unimplemented(response);
}
@Override
public void setCdmaBroadcastConfig(CdmaSmsBroadcastConfigInfo[] configs, Message response) {
unimplemented(response);
}
public void forceDataDormancy(Message response) {
unimplemented(response);
}
@Override
public void setGsmBroadcastActivation(boolean activate, Message response) {
unimplemented(response);
}
@Override
public void setGsmBroadcastConfig(SmsBroadcastConfigInfo[] config, Message response) {
unimplemented(response);
}
@Override
public void getGsmBroadcastConfig(Message response) {
unimplemented(response);
}
@Override
public void supplyIccPinForApp(String pin, String aid, Message response) {
SimulatedCommandsVerifier.getInstance().supplyIccPinForApp(pin, aid, response);
if (mPinCode != null && mPinCode.equals(pin)) {
resultSuccess(response, null);
return;
}
Rlog.i(LOG_TAG, "[SimCmd] supplyIccPinForApp: pin failed!");
CommandException ex = new CommandException(
CommandException.Error.PASSWORD_INCORRECT);
resultFail(response, new int[]{
(--mPin1attemptsRemaining < 0) ? 0 : mPin1attemptsRemaining}, ex);
}
@Override
public void supplyIccPukForApp(String puk, String newPin, String aid, Message response) {
unimplemented(response);
}
@Override
public void supplyIccPin2ForApp(String pin2, String aid, Message response) {
unimplemented(response);
}
@Override
public void supplyIccPuk2ForApp(String puk2, String newPin2, String aid, Message response) {
unimplemented(response);
}
@Override
public void changeIccPinForApp(String oldPin, String newPin, String aidPtr, Message response) {
SimulatedCommandsVerifier.getInstance().changeIccPinForApp(oldPin, newPin, aidPtr,
response);
changeIccPin(oldPin, newPin, response);
}
@Override
public void changeIccPin2ForApp(String oldPin2, String newPin2, String aidPtr,
Message response) {
unimplemented(response);
}
@Override
public void requestIsimAuthentication(String nonce, Message response) {
unimplemented(response);
}
@Override
public void requestIccSimAuthentication(int authContext, String data, String aid, Message response) {
unimplemented(response);
}
@Override
public void getVoiceRadioTechnology(Message response) {
SimulatedCommandsVerifier.getInstance().getVoiceRadioTechnology(response);
int ret[] = new int[1];
ret[0] = mVoiceRadioTech;
resultSuccess(response, ret);
}
public void setCellInfoList(List<CellInfo> list) {
mCellInfoList = list;
}
@Override
public void getCellInfoList(Message response) {
if (mCellInfoList == null) {
Parcel p = Parcel.obtain();
p.writeInt(1);
p.writeInt(1);
p.writeInt(2);
p.writeLong(1453510289108L);
p.writeInt(310);
p.writeInt(260);
p.writeInt(123);
p.writeInt(456);
p.writeInt(99);
p.writeInt(3);
p.setDataPosition(0);
CellInfoGsm cellInfo = CellInfoGsm.CREATOR.createFromParcel(p);
ArrayList<CellInfo> mCellInfoList = new ArrayList();
mCellInfoList.add(cellInfo);
}
resultSuccess(response, mCellInfoList);
}
@Override
public int getRilVersion() {
return 11;
}
@Override
public void setCellInfoListRate(int rateInMillis, Message response) {
unimplemented(response);
}
@Override
public void setInitialAttachApn(String apn, String protocol, int authType, String username,
String password, Message result) {
}
@Override
public void setDataProfile(DataProfile[] dps, Message result) {
}
public void setImsRegistrationState(int[] regState) {
mImsRegState = regState;
}
@Override
public void getImsRegistrationState(Message response) {
if (mImsRegState == null) {
mImsRegState = new int[]{1, PhoneConstants.PHONE_TYPE_NONE};
}
resultSuccess(response, mImsRegState);
}
@Override
public void sendImsCdmaSms(byte[] pdu, int retry, int messageRef,
Message response){
SimulatedCommandsVerifier.getInstance().sendImsCdmaSms(pdu, retry, messageRef, response);
resultSuccess(response, new SmsResponse(0 /*messageRef*/, null, 0));
}
@Override
public void sendImsGsmSms(String smscPDU, String pdu,
int retry, int messageRef, Message response){
SimulatedCommandsVerifier.getInstance().sendImsGsmSms(smscPDU, pdu, retry, messageRef,
response);
resultSuccess(response, new SmsResponse(0 /*messageRef*/, null, 0));
}
@Override
public void iccOpenLogicalChannel(String AID, Message response) {
SimulatedCommandsVerifier.getInstance().iccOpenLogicalChannel(AID, response);
Object result = new int[]{mChannelId};
resultSuccess(response, result);
}
@Override
public void iccOpenLogicalChannel(String AID, byte p2, Message response) {
unimplemented(response);
}
@Override
public void iccCloseLogicalChannel(int channel, Message response) {
unimplemented(response);
}
@Override
public void iccTransmitApduLogicalChannel(int channel, int cla, int instruction,
int p1, int p2, int p3, String data,
Message response) {
SimulatedCommandsVerifier.getInstance().iccTransmitApduLogicalChannel(channel, cla,
instruction, p1, p2, p3, data, response);
if(mIccIoResultForApduLogicalChannel!=null) {
resultSuccess(response, mIccIoResultForApduLogicalChannel);
}else {
resultFail(response, null, new RuntimeException("IccIoResult not set"));
}
}
@Override
public void iccTransmitApduBasicChannel(int cla, int instruction, int p1, int p2,
int p3, String data, Message response) {
unimplemented(response);
}
@Override
public void getAtr(Message response) {
unimplemented(response);
}
@Override
public void nvReadItem(int itemID, Message response) {
unimplemented(response);
}
@Override
public void nvWriteItem(int itemID, String itemValue, Message response) {
unimplemented(response);
}
@Override
public void nvWriteCdmaPrl(byte[] preferredRoamingList, Message response) {
unimplemented(response);
}
@Override
public void nvResetConfig(int resetType, Message response) {
unimplemented(response);
}
@Override
public void getHardwareConfig(Message result) {
unimplemented(result);
}
@Override
public void requestShutdown(Message result) {
setRadioState(RadioState.RADIO_UNAVAILABLE);
}
@Override
public void startLceService(int report_interval_ms, boolean pullMode, Message result) {
SimulatedCommandsVerifier.getInstance().startLceService(report_interval_ms, pullMode,
result);
unimplemented(result);
}
@Override
public void stopLceService(Message result) {
unimplemented(result);
}
@Override
public void pullLceData(Message result) {
unimplemented(result);
}
@Override
public void getModemActivityInfo(Message result) {
unimplemented(result);
}
@Override
public void setAllowedCarriers(List<CarrierIdentifier> carriers, Message result) {
unimplemented(result);
}
@Override
public void getAllowedCarriers(Message result) {
unimplemented(result);
}
@Override
public void getRadioCapability(Message result) {
SimulatedCommandsVerifier.getInstance().getRadioCapability(result);
resultSuccess(result, new RadioCapability(0, 0, 0, 0xFFFF, null, 0));
}
public void notifySmsStatus(Object result) {
if (mSmsStatusRegistrant != null) {
mSmsStatusRegistrant.notifyRegistrant(new AsyncResult(null, result, null));
}
}
public void notifyGsmBroadcastSms(Object result) {
if (mGsmBroadcastSmsRegistrant != null) {
mGsmBroadcastSmsRegistrant.notifyRegistrant(new AsyncResult(null, result, null));
}
}
public void notifyIccSmsFull() {
if (mIccSmsFullRegistrant != null) {
mIccSmsFullRegistrant.notifyRegistrant();
}
}
public void notifyEmergencyCallbackMode() {
if (mEmergencyCallbackModeRegistrant != null) {
mEmergencyCallbackModeRegistrant.notifyRegistrant();
}
}
@Override
public void setEmergencyCallbackMode(Handler h, int what, Object obj) {
SimulatedCommandsVerifier.getInstance().setEmergencyCallbackMode(h, what, obj);
super.setEmergencyCallbackMode(h, what, obj);
}
public void notifyExitEmergencyCallbackMode() {
if (mExitEmergencyCallbackModeRegistrants != null) {
mExitEmergencyCallbackModeRegistrants.notifyRegistrants(
new AsyncResult (null, null, null));
}
}
public void notifyImsNetworkStateChanged() {
if(mImsNetworkStateChangedRegistrants != null) {
mImsNetworkStateChangedRegistrants.notifyRegistrants();
}
}
@Override
public void registerForExitEmergencyCallbackMode(Handler h, int what, Object obj) {
SimulatedCommandsVerifier.getInstance().registerForExitEmergencyCallbackMode(h, what, obj);
super.registerForExitEmergencyCallbackMode(h, what, obj);
}
public void notifyRadioOn() {
mOnRegistrants.notifyRegistrants();
}
@VisibleForTesting
public void notifyVoiceNetworkStateChanged() {
mVoiceNetworkStateRegistrants.notifyRegistrants();
}
@VisibleForTesting
public void notifyOtaProvisionStatusChanged() {
if (mOtaProvisionRegistrants != null) {
int ret[] = new int[1];
ret[0] = Phone.CDMA_OTA_PROVISION_STATUS_COMMITTED;
mOtaProvisionRegistrants.notifyRegistrants(new AsyncResult(null, ret, null));
}
}
public void notifySignalStrength() {
if (mSignalStrength == null) {
mSignalStrength = new SignalStrength(
20, // gsmSignalStrength
0, // gsmBitErrorRate
-1, // cdmaDbm
-1, // cdmaEcio
-1, // evdoDbm
-1, // evdoEcio
-1, // evdoSnr
99, // lteSignalStrength
SignalStrength.INVALID, // lteRsrp
SignalStrength.INVALID, // lteRsrq
SignalStrength.INVALID, // lteRssnr
SignalStrength.INVALID, // lteCqi
SignalStrength.INVALID, // tdScdmaRscp
true // gsmFlag
);
}
if (mSignalStrengthRegistrant != null) {
mSignalStrengthRegistrant.notifyRegistrant(
new AsyncResult (null, mSignalStrength, null));
}
}
public void setIccCardStatus(IccCardStatus iccCardStatus){
mIccCardStatus = iccCardStatus;
}
public void setIccIoResultForApduLogicalChannel(IccIoResult iccIoResult) {
mIccIoResultForApduLogicalChannel = iccIoResult;
}
public void setOpenChannelId(int channelId) {
mChannelId = channelId;
}
public void setPin1RemainingAttempt(int pin1attemptsRemaining) {
mPin1attemptsRemaining = pin1attemptsRemaining;
}
private AtomicBoolean mAllowed = new AtomicBoolean(false);
@Override
public void setDataAllowed(boolean allowed, Message result) {
log("setDataAllowed = " + allowed);
mAllowed.set(allowed);
resultSuccess(result, null);
}
@VisibleForTesting
public boolean isDataAllowed() {
return mAllowed.get();
}
@Override
public void registerForPcoData(Handler h, int what, Object obj) {
}
@Override
public void unregisterForPcoData(Handler h) {
}
}