| /* |
| * 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)); |
| } |
| } |
| } |
