798 lines
30 KiB
Java
798 lines
30 KiB
Java
/*
|
|
* Copyright (C) 2021 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.os.RemoteException;
|
|
import android.telephony.CarrierRestrictionRules;
|
|
import android.telephony.ImsiEncryptionInfo;
|
|
import android.telephony.Rlog;
|
|
|
|
import com.android.internal.telephony.uicc.IccCardApplicationStatus.PersoSubState;
|
|
import com.android.internal.telephony.uicc.SimPhonebookRecord;
|
|
|
|
/**
|
|
* A holder for IRadioSim.
|
|
* Use getAidl to get IRadioSim and call the AIDL implementations of the HAL APIs.
|
|
*/
|
|
public class RadioSimProxy extends RadioServiceProxy {
|
|
private static final String TAG = "RadioSimProxy";
|
|
private volatile android.hardware.radio.sim.IRadioSim mSimProxy = null;
|
|
|
|
/**
|
|
* Set IRadioSim as the AIDL implementation for RadioServiceProxy
|
|
* @param halVersion Radio HAL version
|
|
* @param sim IRadioSim implementation
|
|
*
|
|
* @return updated HAL version
|
|
*/
|
|
public HalVersion setAidl(HalVersion halVersion, android.hardware.radio.sim.IRadioSim sim) {
|
|
HalVersion version = halVersion;
|
|
try {
|
|
version = RIL.getServiceHalVersion(sim.getInterfaceVersion());
|
|
} catch (RemoteException e) {
|
|
Rlog.e(TAG, "setAidl: " + e);
|
|
}
|
|
mHalVersion = version;
|
|
mSimProxy = sim;
|
|
mIsAidl = true;
|
|
|
|
Rlog.d(TAG, "AIDL initialized mHalVersion=" + mHalVersion);
|
|
return mHalVersion;
|
|
}
|
|
|
|
/**
|
|
* Get the AIDL implementation of RadioSimProxy
|
|
* @return IRadioSim implementation
|
|
*/
|
|
public android.hardware.radio.sim.IRadioSim getAidl() {
|
|
return mSimProxy;
|
|
}
|
|
|
|
/**
|
|
* Reset RadioSimProxy
|
|
*/
|
|
@Override
|
|
public void clear() {
|
|
super.clear();
|
|
mSimProxy = null;
|
|
}
|
|
|
|
/**
|
|
* Check whether a RadioSim implementation exists
|
|
* @return true if there is neither a HIDL nor AIDL implementation
|
|
*/
|
|
@Override
|
|
public boolean isEmpty() {
|
|
return mRadioProxy == null && mSimProxy == null;
|
|
}
|
|
|
|
/**
|
|
* Call IRadioSim#areUiccApplicationsEnabled
|
|
* @param serial Serial number of request
|
|
* @throws RemoteException
|
|
*/
|
|
public void areUiccApplicationsEnabled(int serial) throws RemoteException {
|
|
if (isEmpty() || mHalVersion.less(RIL.RADIO_HAL_VERSION_1_5)) return;
|
|
if (isAidl()) {
|
|
mSimProxy.areUiccApplicationsEnabled(serial);
|
|
} else {
|
|
((android.hardware.radio.V1_5.IRadio) mRadioProxy).areUiccApplicationsEnabled(serial);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Call IRadioSim#changeIccPin2ForApp
|
|
* @param serial Serial number of request
|
|
* @param oldPin2 Old PIN value
|
|
* @param newPin2 New PIN value
|
|
* @param aid Application ID
|
|
* @throws RemoteException
|
|
*/
|
|
public void changeIccPin2ForApp(int serial, String oldPin2, String newPin2, String aid)
|
|
throws RemoteException {
|
|
if (isEmpty()) return;
|
|
if (isAidl()) {
|
|
mSimProxy.changeIccPin2ForApp(serial, oldPin2, newPin2, aid);
|
|
} else {
|
|
mRadioProxy.changeIccPin2ForApp(serial, oldPin2, newPin2, aid);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Call IRadioSim#changeIccPinForApp
|
|
* @param serial Serial number of request
|
|
* @param oldPin Old PIN value
|
|
* @param newPin New PIN value
|
|
* @param aid Application ID
|
|
* @throws RemoteException
|
|
*/
|
|
public void changeIccPinForApp(int serial, String oldPin, String newPin, String aid)
|
|
throws RemoteException {
|
|
if (isEmpty()) return;
|
|
if (isAidl()) {
|
|
mSimProxy.changeIccPinForApp(serial, oldPin, newPin, aid);
|
|
} else {
|
|
mRadioProxy.changeIccPinForApp(serial, oldPin, newPin, aid);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Call IRadioSim#enableUiccApplications
|
|
* @param serial Serial number of request
|
|
* @param enable Whether or not to enable UiccApplications on the SIM
|
|
* @throws RemoteException
|
|
*/
|
|
public void enableUiccApplications(int serial, boolean enable) throws RemoteException {
|
|
if (isEmpty() || mHalVersion.less(RIL.RADIO_HAL_VERSION_1_5)) return;
|
|
if (isAidl()) {
|
|
mSimProxy.enableUiccApplications(serial, enable);
|
|
} else {
|
|
((android.hardware.radio.V1_5.IRadio) mRadioProxy).enableUiccApplications(
|
|
serial, enable);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Call IRadioSim#getAllowedCarriers
|
|
* @param serial Serial number of request
|
|
* @throws RemoteException
|
|
*/
|
|
public void getAllowedCarriers(int serial) throws RemoteException {
|
|
if (isEmpty()) return;
|
|
if (isAidl()) {
|
|
mSimProxy.getAllowedCarriers(serial);
|
|
} else {
|
|
mRadioProxy.getAllowedCarriers_1_4(serial);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Call IRadioSim#getCdmaSubscription
|
|
* @param serial Serial number of request
|
|
* @throws RemoteException
|
|
*/
|
|
public void getCdmaSubscription(int serial) throws RemoteException {
|
|
if (isEmpty()) return;
|
|
if (isAidl()) {
|
|
mSimProxy.getCdmaSubscription(serial);
|
|
} else {
|
|
mRadioProxy.getCDMASubscription(serial);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Call IRadioSim#getCdmaSubscriptionSource
|
|
* @param serial Serial number of request
|
|
* @throws RemoteException
|
|
*/
|
|
public void getCdmaSubscriptionSource(int serial) throws RemoteException {
|
|
if (isEmpty()) return;
|
|
if (isAidl()) {
|
|
mSimProxy.getCdmaSubscriptionSource(serial);
|
|
} else {
|
|
mRadioProxy.getCdmaSubscriptionSource(serial);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Call IRadioSim#getFacilityLockForApp
|
|
* @param serial Serial number of request
|
|
* @param facility One of CB_FACILTY_*
|
|
* @param password Password or "" if not required
|
|
* @param serviceClass Sum of SERVICE_CLASS_*
|
|
* @param appId Application ID or null if none
|
|
* @throws RemoteException
|
|
*/
|
|
public void getFacilityLockForApp(int serial, String facility, String password,
|
|
int serviceClass, String appId) throws RemoteException {
|
|
if (isEmpty()) return;
|
|
if (isAidl()) {
|
|
mSimProxy.getFacilityLockForApp(serial, facility, password, serviceClass, appId);
|
|
} else {
|
|
mRadioProxy.getFacilityLockForApp(serial, facility, password, serviceClass, appId);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Call IRadioSim#getIccCardStatus
|
|
* @param serial Serial number of request
|
|
* @throws RemoteException
|
|
*/
|
|
public void getIccCardStatus(int serial) throws RemoteException {
|
|
if (isEmpty()) return;
|
|
if (isAidl()) {
|
|
mSimProxy.getIccCardStatus(serial);
|
|
} else {
|
|
mRadioProxy.getIccCardStatus(serial);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Call IRadioSim#getImsiForApp
|
|
* @param serial Serial number of request
|
|
* @param aid Application ID
|
|
* @throws RemoteException
|
|
*/
|
|
public void getImsiForApp(int serial, String aid) throws RemoteException {
|
|
if (isEmpty()) return;
|
|
if (isAidl()) {
|
|
mSimProxy.getImsiForApp(serial, aid);
|
|
} else {
|
|
mRadioProxy.getImsiForApp(serial, aid);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Call IRadioSim#getSimPhonebookCapacity
|
|
* @param serial Serial number of request
|
|
* @throws RemoteException
|
|
*/
|
|
public void getSimPhonebookCapacity(int serial) throws RemoteException {
|
|
if (isEmpty() || mHalVersion.less(RIL.RADIO_HAL_VERSION_1_6)) return;
|
|
if (isAidl()) {
|
|
mSimProxy.getSimPhonebookCapacity(serial);
|
|
} else {
|
|
((android.hardware.radio.V1_6.IRadio) mRadioProxy).getSimPhonebookCapacity(serial);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Call IRadioSim#getSimPhonebookRecords
|
|
* @param serial Serial number of request
|
|
* @throws RemoteException
|
|
*/
|
|
public void getSimPhonebookRecords(int serial) throws RemoteException {
|
|
if (isEmpty() || mHalVersion.less(RIL.RADIO_HAL_VERSION_1_6)) return;
|
|
if (isAidl()) {
|
|
mSimProxy.getSimPhonebookRecords(serial);
|
|
} else {
|
|
((android.hardware.radio.V1_6.IRadio) mRadioProxy).getSimPhonebookRecords(serial);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Call IRadioSim#iccCloseLogicalChannelWithSessionInfo
|
|
* @param serial Serial number of request
|
|
* @param channelId Channel ID of the channel to be closed
|
|
* @param isEs10 Whether the logical channel is opened for performing ES10 operations.
|
|
* @throws RemoteException
|
|
*/
|
|
public void iccCloseLogicalChannel(int serial,
|
|
int channelId, boolean isEs10) throws RemoteException {
|
|
if (isEmpty()) return;
|
|
if (isAidl()) {
|
|
if (mHalVersion.greaterOrEqual(RIL.RADIO_HAL_VERSION_2_1)) {
|
|
android.hardware.radio.sim.SessionInfo info =
|
|
new android.hardware.radio.sim.SessionInfo();
|
|
info.sessionId = channelId;
|
|
info.isEs10 = isEs10;
|
|
mSimProxy.iccCloseLogicalChannelWithSessionInfo(serial, info);
|
|
return;
|
|
}
|
|
mSimProxy.iccCloseLogicalChannel(serial, channelId);
|
|
} else {
|
|
mRadioProxy.iccCloseLogicalChannel(serial, channelId);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Call IRadioSim#iccIoForApp
|
|
* @param serial Serial number of request
|
|
* @param command Command
|
|
* @param fileId File ID
|
|
* @param path Path
|
|
* @param p1 P1 value of the command
|
|
* @param p2 P2 value of the command
|
|
* @param p3 P3 value of the command
|
|
* @param data Data to be sent
|
|
* @param pin2 PIN 2 value
|
|
* @param aid Application ID
|
|
* @throws RemoteException
|
|
*/
|
|
public void iccIoForApp(int serial, int command, int fileId, String path, int p1, int p2,
|
|
int p3, String data, String pin2, String aid) throws RemoteException {
|
|
if (isEmpty()) return;
|
|
if (isAidl()) {
|
|
android.hardware.radio.sim.IccIo iccIo = new android.hardware.radio.sim.IccIo();
|
|
iccIo.command = command;
|
|
iccIo.fileId = fileId;
|
|
iccIo.path = path;
|
|
iccIo.p1 = p1;
|
|
iccIo.p2 = p2;
|
|
iccIo.p3 = p3;
|
|
iccIo.data = data;
|
|
iccIo.pin2 = pin2;
|
|
iccIo.aid = aid;
|
|
mSimProxy.iccIoForApp(serial, iccIo);
|
|
} else {
|
|
android.hardware.radio.V1_0.IccIo iccIo = new android.hardware.radio.V1_0.IccIo();
|
|
iccIo.command = command;
|
|
iccIo.fileId = fileId;
|
|
iccIo.path = path;
|
|
iccIo.p1 = p1;
|
|
iccIo.p2 = p2;
|
|
iccIo.p3 = p3;
|
|
iccIo.data = data;
|
|
iccIo.pin2 = pin2;
|
|
iccIo.aid = aid;
|
|
mRadioProxy.iccIOForApp(serial, iccIo);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Call IRadioSim#iccOpenLogicalChannel
|
|
* @param serial Serial number of request
|
|
* @param aid Application ID
|
|
* @param p2 P2 value of the command
|
|
* @throws RemoteException
|
|
*/
|
|
public void iccOpenLogicalChannel(int serial, String aid, int p2) throws RemoteException {
|
|
if (isEmpty()) return;
|
|
if (isAidl()) {
|
|
mSimProxy.iccOpenLogicalChannel(serial, aid, p2);
|
|
} else {
|
|
mRadioProxy.iccOpenLogicalChannel(serial, aid, p2);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Call IRadioSim#iccTransmitApduBasicChannel
|
|
* @param serial Serial number of request
|
|
* @param cla Class of the command
|
|
* @param instruction Instruction of the command
|
|
* @param p1 P1 value of the command
|
|
* @param p2 P2 value of the command
|
|
* @param p3 P3 value of the command
|
|
* @param data Data to be sent
|
|
* @throws RemoteException
|
|
*/
|
|
public void iccTransmitApduBasicChannel(int serial, int cla, int instruction, int p1, int p2,
|
|
int p3, String data) throws RemoteException {
|
|
if (isEmpty()) return;
|
|
if (isAidl()) {
|
|
mSimProxy.iccTransmitApduBasicChannel(serial,
|
|
RILUtils.convertToHalSimApduAidl(0, cla, instruction, p1, p2, p3, data,
|
|
false, mHalVersion));
|
|
} else {
|
|
mRadioProxy.iccTransmitApduBasicChannel(serial,
|
|
RILUtils.convertToHalSimApdu(0, cla, instruction, p1, p2, p3, data));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Call IRadioSim#iccTransmitApduLogicalChannel
|
|
* @param serial Serial number of request
|
|
* @param channel Channel ID of the channel to use for communication
|
|
* @param cla Class of the command
|
|
* @param instruction Instruction of the command
|
|
* @param p1 P1 value of the command
|
|
* @param p2 P2 value of the command
|
|
* @param p3 P3 value of the command
|
|
* @param data Data to be sent
|
|
* @throws RemoteException
|
|
*/
|
|
public void iccTransmitApduLogicalChannel(int serial, int channel, int cla, int instruction,
|
|
int p1, int p2, int p3, String data) throws RemoteException {
|
|
iccTransmitApduLogicalChannel(serial, channel, cla, instruction, p1, p2, p3, data, false);
|
|
}
|
|
|
|
/**
|
|
* Call IRadioSim#iccTransmitApduLogicalChannel
|
|
* @param serial Serial number of request
|
|
* @param channel Channel ID of the channel to use for communication
|
|
* @param cla Class of the command
|
|
* @param instruction Instruction of the command
|
|
* @param p1 P1 value of the command
|
|
* @param p2 P2 value of the command
|
|
* @param p3 P3 value of the command
|
|
* @param data Data to be sent
|
|
* @param isEs10Command APDU is an isEs10 command or not
|
|
* @throws RemoteException
|
|
*/
|
|
public void iccTransmitApduLogicalChannel(int serial, int channel, int cla, int instruction,
|
|
int p1, int p2, int p3, String data, boolean isEs10Command) throws RemoteException {
|
|
if (isEmpty()) return;
|
|
if (isAidl()) {
|
|
mSimProxy.iccTransmitApduLogicalChannel(serial,
|
|
RILUtils.convertToHalSimApduAidl(channel, cla, instruction, p1, p2, p3, data,
|
|
isEs10Command, mHalVersion));
|
|
} else {
|
|
mRadioProxy.iccTransmitApduLogicalChannel(serial,
|
|
RILUtils.convertToHalSimApdu(channel, cla, instruction, p1, p2, p3, data));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Call IRadioSim#reportStkServiceIsRunning
|
|
* @param serial Serial number of request
|
|
* @throws RemoteException
|
|
*/
|
|
public void reportStkServiceIsRunning(int serial) throws RemoteException {
|
|
if (isEmpty()) return;
|
|
if (isAidl()) {
|
|
mSimProxy.reportStkServiceIsRunning(serial);
|
|
} else {
|
|
mRadioProxy.reportStkServiceIsRunning(serial);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Call IRadioSim#requestIccSimAuthentication
|
|
* @param serial Serial number of request
|
|
* @param authContext P2 parameter that specifies the authentication context
|
|
* @param authData Authentication challenge data
|
|
* @param aid Application ID of the application/slot to send the auth command to
|
|
* @throws RemoteException
|
|
*/
|
|
public void requestIccSimAuthentication(int serial, int authContext, String authData,
|
|
String aid) throws RemoteException {
|
|
if (isEmpty()) return;
|
|
if (isAidl()) {
|
|
mSimProxy.requestIccSimAuthentication(serial, authContext, authData, aid);
|
|
} else {
|
|
mRadioProxy.requestIccSimAuthentication(serial, authContext, authData, aid);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Call IRadioSim#responseAcknowledgement
|
|
* @throws RemoteException
|
|
*/
|
|
@Override
|
|
public void responseAcknowledgement() throws RemoteException {
|
|
if (isEmpty()) return;
|
|
if (isAidl()) {
|
|
mSimProxy.responseAcknowledgement();
|
|
} else {
|
|
mRadioProxy.responseAcknowledgement();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Call IRadioSim#sendEnvelope
|
|
* @param serial Serial number of request
|
|
* @param contents String containing SAT/USAT response in hexadecimal format starting with
|
|
* command tag
|
|
* @throws RemoteException
|
|
*/
|
|
public void sendEnvelope(int serial, String contents) throws RemoteException {
|
|
if (isEmpty()) return;
|
|
if (isAidl()) {
|
|
mSimProxy.sendEnvelope(serial, contents);
|
|
} else {
|
|
mRadioProxy.sendEnvelope(serial, contents);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Call IRadioSim#sendEnvelopeWithStatus
|
|
* @param serial Serial number of request
|
|
* @param contents String containing SAT/USAT response in hexadecimal format starting with
|
|
* command tag
|
|
* @throws RemoteException
|
|
*/
|
|
public void sendEnvelopeWithStatus(int serial, String contents) throws RemoteException {
|
|
if (isEmpty()) return;
|
|
if (isAidl()) {
|
|
mSimProxy.sendEnvelopeWithStatus(serial, contents);
|
|
} else {
|
|
mRadioProxy.sendEnvelopeWithStatus(serial, contents);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Call IRadioSim#sendTerminalResponseToSim
|
|
* @param serial Serial number of request
|
|
* @param contents String containing SAT/USAT response in hexadecimal format starting with
|
|
* first byte of response data
|
|
* @throws RemoteException
|
|
*/
|
|
public void sendTerminalResponseToSim(int serial, String contents) throws RemoteException {
|
|
if (isEmpty()) return;
|
|
if (isAidl()) {
|
|
mSimProxy.sendTerminalResponseToSim(serial, contents);
|
|
} else {
|
|
mRadioProxy.sendTerminalResponseToSim(serial, contents);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Call IRadioSim#setAllowedCarriers
|
|
* @param serial Serial number of request
|
|
* @param carrierRestrictionRules Allowed carriers
|
|
* @throws RemoteException
|
|
*/
|
|
public void setAllowedCarriers(int serial, CarrierRestrictionRules carrierRestrictionRules)
|
|
throws RemoteException {
|
|
if (isEmpty()) return;
|
|
if (isAidl()) {
|
|
// Prepare structure with allowed list, excluded list and priority
|
|
android.hardware.radio.sim.CarrierRestrictions carrierRestrictions =
|
|
new android.hardware.radio.sim.CarrierRestrictions();
|
|
carrierRestrictions.allowedCarriers = RILUtils.convertToHalCarrierRestrictionListAidl(
|
|
carrierRestrictionRules.getAllowedCarriers());
|
|
carrierRestrictions.excludedCarriers = RILUtils.convertToHalCarrierRestrictionListAidl(
|
|
carrierRestrictionRules.getExcludedCarriers());
|
|
carrierRestrictions.allowedCarriersPrioritized =
|
|
(carrierRestrictionRules.getDefaultCarrierRestriction()
|
|
== CarrierRestrictionRules.CARRIER_RESTRICTION_DEFAULT_NOT_ALLOWED);
|
|
mSimProxy.setAllowedCarriers(serial, carrierRestrictions,
|
|
RILUtils.convertToHalSimLockMultiSimPolicyAidl(
|
|
carrierRestrictionRules.getMultiSimPolicy()));
|
|
} else {
|
|
// Prepare structure with allowed list, excluded list and priority
|
|
android.hardware.radio.V1_4.CarrierRestrictionsWithPriority carrierRestrictions =
|
|
new android.hardware.radio.V1_4.CarrierRestrictionsWithPriority();
|
|
carrierRestrictions.allowedCarriers = RILUtils.convertToHalCarrierRestrictionList(
|
|
carrierRestrictionRules.getAllowedCarriers());
|
|
carrierRestrictions.excludedCarriers = RILUtils.convertToHalCarrierRestrictionList(
|
|
carrierRestrictionRules.getExcludedCarriers());
|
|
carrierRestrictions.allowedCarriersPrioritized =
|
|
(carrierRestrictionRules.getDefaultCarrierRestriction()
|
|
== CarrierRestrictionRules.CARRIER_RESTRICTION_DEFAULT_NOT_ALLOWED);
|
|
mRadioProxy.setAllowedCarriers_1_4(serial, carrierRestrictions,
|
|
RILUtils.convertToHalSimLockMultiSimPolicy(
|
|
carrierRestrictionRules.getMultiSimPolicy()));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Call IRadioSim#setCarrierInfoForImsiEncryption
|
|
* @param serial Serial number of request
|
|
* @param imsiEncryptionInfo ImsiEncryptionInfo
|
|
* @throws RemoteException
|
|
*/
|
|
public void setCarrierInfoForImsiEncryption(int serial, ImsiEncryptionInfo imsiEncryptionInfo)
|
|
throws RemoteException {
|
|
if (isEmpty()) return;
|
|
if (isAidl()) {
|
|
android.hardware.radio.sim.ImsiEncryptionInfo halImsiInfo =
|
|
new android.hardware.radio.sim.ImsiEncryptionInfo();
|
|
halImsiInfo.mnc = imsiEncryptionInfo.getMnc();
|
|
halImsiInfo.mcc = imsiEncryptionInfo.getMcc();
|
|
halImsiInfo.keyIdentifier = imsiEncryptionInfo.getKeyIdentifier();
|
|
if (imsiEncryptionInfo.getExpirationTime() != null) {
|
|
halImsiInfo.expirationTime = imsiEncryptionInfo.getExpirationTime().getTime();
|
|
}
|
|
halImsiInfo.carrierKey = imsiEncryptionInfo.getPublicKey().getEncoded();
|
|
halImsiInfo.keyType = (byte) imsiEncryptionInfo.getKeyType();
|
|
|
|
mSimProxy.setCarrierInfoForImsiEncryption(serial, halImsiInfo);
|
|
} else if (mHalVersion.greaterOrEqual(RIL.RADIO_HAL_VERSION_1_6)) {
|
|
android.hardware.radio.V1_6.ImsiEncryptionInfo halImsiInfo =
|
|
new android.hardware.radio.V1_6.ImsiEncryptionInfo();
|
|
halImsiInfo.base.mnc = imsiEncryptionInfo.getMnc();
|
|
halImsiInfo.base.mcc = imsiEncryptionInfo.getMcc();
|
|
halImsiInfo.base.keyIdentifier = imsiEncryptionInfo.getKeyIdentifier();
|
|
if (imsiEncryptionInfo.getExpirationTime() != null) {
|
|
halImsiInfo.base.expirationTime = imsiEncryptionInfo.getExpirationTime().getTime();
|
|
}
|
|
for (byte b : imsiEncryptionInfo.getPublicKey().getEncoded()) {
|
|
halImsiInfo.base.carrierKey.add(Byte.valueOf(b));
|
|
}
|
|
halImsiInfo.keyType = (byte) imsiEncryptionInfo.getKeyType();
|
|
|
|
((android.hardware.radio.V1_6.IRadio) mRadioProxy).setCarrierInfoForImsiEncryption_1_6(
|
|
serial, halImsiInfo);
|
|
} else {
|
|
android.hardware.radio.V1_1.ImsiEncryptionInfo halImsiInfo =
|
|
new android.hardware.radio.V1_1.ImsiEncryptionInfo();
|
|
halImsiInfo.mnc = imsiEncryptionInfo.getMnc();
|
|
halImsiInfo.mcc = imsiEncryptionInfo.getMcc();
|
|
halImsiInfo.keyIdentifier = imsiEncryptionInfo.getKeyIdentifier();
|
|
if (imsiEncryptionInfo.getExpirationTime() != null) {
|
|
halImsiInfo.expirationTime = imsiEncryptionInfo.getExpirationTime().getTime();
|
|
}
|
|
for (byte b : imsiEncryptionInfo.getPublicKey().getEncoded()) {
|
|
halImsiInfo.carrierKey.add(Byte.valueOf(b));
|
|
}
|
|
|
|
mRadioProxy.setCarrierInfoForImsiEncryption(serial, halImsiInfo);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Call IRadioSim#setCdmaSubscriptionSource
|
|
* @param serial Serial number of request
|
|
* @param cdmaSub One of CDMA_SUBSCRIPTION_*
|
|
* @throws RemoteException
|
|
*/
|
|
public void setCdmaSubscriptionSource(int serial, int cdmaSub) throws RemoteException {
|
|
if (isEmpty()) return;
|
|
if (isAidl()) {
|
|
mSimProxy.setCdmaSubscriptionSource(serial, cdmaSub);
|
|
} else {
|
|
mRadioProxy.setCdmaSubscriptionSource(serial, cdmaSub);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Call IRadioSim#setFacilityLockForApp
|
|
* @param serial Serial number of request
|
|
* @param facility One of CB_FACILTY_*
|
|
* @param lockState True means lock, false means unlock
|
|
* @param password Password or "" if not required
|
|
* @param serviceClass Sum of SERVICE_CLASS_*
|
|
* @param appId Application ID or null if none
|
|
* @throws RemoteException
|
|
*/
|
|
public void setFacilityLockForApp(int serial, String facility, boolean lockState,
|
|
String password, int serviceClass, String appId) throws RemoteException {
|
|
if (isEmpty()) return;
|
|
if (isAidl()) {
|
|
mSimProxy.setFacilityLockForApp(
|
|
serial, facility, lockState, password, serviceClass, appId);
|
|
} else {
|
|
mRadioProxy.setFacilityLockForApp(
|
|
serial, facility, lockState, password, serviceClass, appId);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Call IRadioSim#setSimCardPower
|
|
* @param serial Serial number of request
|
|
* @param state SIM state (power down, power up, pass through)
|
|
* @throws RemoteException
|
|
*/
|
|
public void setSimCardPower(int serial, int state) throws RemoteException {
|
|
if (isEmpty()) return;
|
|
if (isAidl()) {
|
|
mSimProxy.setSimCardPower(serial, state);
|
|
} else if (mHalVersion.greaterOrEqual(RIL.RADIO_HAL_VERSION_1_6)) {
|
|
((android.hardware.radio.V1_6.IRadio) mRadioProxy).setSimCardPower_1_6(serial, state);
|
|
} else {
|
|
mRadioProxy.setSimCardPower_1_1(serial, state);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Call IRadioSim#setUiccSubscription
|
|
* @param serial Serial number of request
|
|
* @param slotId Slot ID
|
|
* @param appIndex Application index in the card
|
|
* @param subId Subscription ID
|
|
* @param subStatus Activation status; 1 = activate and 0 = deactivate
|
|
* @throws RemoteException
|
|
*/
|
|
public void setUiccSubscription(int serial, int slotId, int appIndex, int subId, int subStatus)
|
|
throws RemoteException {
|
|
if (isEmpty()) return;
|
|
if (isAidl()) {
|
|
android.hardware.radio.sim.SelectUiccSub info =
|
|
new android.hardware.radio.sim.SelectUiccSub();
|
|
info.slot = slotId;
|
|
info.appIndex = appIndex;
|
|
info.subType = subId;
|
|
info.actStatus = subStatus;
|
|
mSimProxy.setUiccSubscription(serial, info);
|
|
} else {
|
|
android.hardware.radio.V1_0.SelectUiccSub info =
|
|
new android.hardware.radio.V1_0.SelectUiccSub();
|
|
info.slot = slotId;
|
|
info.appIndex = appIndex;
|
|
info.subType = subId;
|
|
info.actStatus = subStatus;
|
|
mRadioProxy.setUiccSubscription(serial, info);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Call IRadioSim#supplyIccPin2ForApp
|
|
* @param serial Serial number of request
|
|
* @param pin2 PIN 2 value
|
|
* @param aid Application ID
|
|
* @throws RemoteException
|
|
*/
|
|
public void supplyIccPin2ForApp(int serial, String pin2, String aid) throws RemoteException {
|
|
if (isEmpty()) return;
|
|
if (isAidl()) {
|
|
mSimProxy.supplyIccPin2ForApp(serial, pin2, aid);
|
|
} else {
|
|
mRadioProxy.supplyIccPin2ForApp(serial, pin2, aid);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Call IRadioSim#supplyIccPinForApp
|
|
* @param serial Serial number of request
|
|
* @param pin PIN value
|
|
* @param aid Application ID
|
|
* @throws RemoteException
|
|
*/
|
|
public void supplyIccPinForApp(int serial, String pin, String aid) throws RemoteException {
|
|
if (isEmpty()) return;
|
|
if (isAidl()) {
|
|
mSimProxy.supplyIccPinForApp(serial, pin, aid);
|
|
} else {
|
|
mRadioProxy.supplyIccPinForApp(serial, pin, aid);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Call IRadioSim#supplyIccPuk2ForApp
|
|
* @param serial Serial number of request
|
|
* @param puk2 PUK 2 value
|
|
* @param pin2 PIN 2 value
|
|
* @param aid Application ID
|
|
* @throws RemoteException
|
|
*/
|
|
public void supplyIccPuk2ForApp(int serial, String puk2, String pin2, String aid)
|
|
throws RemoteException {
|
|
if (isEmpty()) return;
|
|
if (isAidl()) {
|
|
mSimProxy.supplyIccPuk2ForApp(serial, puk2, pin2, aid);
|
|
} else {
|
|
mRadioProxy.supplyIccPuk2ForApp(serial, puk2, pin2, aid);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Call IRadioSim#supplyIccPukForApp
|
|
* @param serial Serial number of request
|
|
* @param puk PUK value
|
|
* @param pin PIN value
|
|
* @param aid Application ID
|
|
* @throws RemoteException
|
|
*/
|
|
public void supplyIccPukForApp(int serial, String puk, String pin, String aid)
|
|
throws RemoteException {
|
|
if (isEmpty()) return;
|
|
if (isAidl()) {
|
|
mSimProxy.supplyIccPukForApp(serial, puk, pin, aid);
|
|
} else {
|
|
mRadioProxy.supplyIccPukForApp(serial, puk, pin, aid);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Call IRadioSim#supplySimDepersonalization
|
|
* @param serial Serial number of request
|
|
* @param persoType SIM personalization type
|
|
* @param controlKey Unlock code for removing SIM personalization from this device
|
|
* @throws RemoteException
|
|
*/
|
|
public void supplySimDepersonalization(int serial, PersoSubState persoType, String controlKey)
|
|
throws RemoteException {
|
|
if (isEmpty() || mHalVersion.less(RIL.RADIO_HAL_VERSION_1_5)) return;
|
|
if (isAidl()) {
|
|
mSimProxy.supplySimDepersonalization(serial,
|
|
RILUtils.convertToHalPersoTypeAidl(persoType), controlKey);
|
|
} else {
|
|
((android.hardware.radio.V1_5.IRadio) mRadioProxy).supplySimDepersonalization(serial,
|
|
RILUtils.convertToHalPersoType(persoType), controlKey);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Call IRadioSim#updateSimPhonebookRecords
|
|
* @param serial Serial number of request
|
|
* @param recordInfo ADN record information to be updated
|
|
* @throws RemoteException
|
|
*/
|
|
public void updateSimPhonebookRecords(int serial, SimPhonebookRecord recordInfo)
|
|
throws RemoteException {
|
|
if (isEmpty() || mHalVersion.less(RIL.RADIO_HAL_VERSION_1_6)) return;
|
|
if (isAidl()) {
|
|
mSimProxy.updateSimPhonebookRecords(serial,
|
|
RILUtils.convertToHalPhonebookRecordInfoAidl(recordInfo));
|
|
} else {
|
|
((android.hardware.radio.V1_6.IRadio) mRadioProxy).updateSimPhonebookRecords(serial,
|
|
RILUtils.convertToHalPhonebookRecordInfo(recordInfo));
|
|
}
|
|
}
|
|
}
|