| /* |
| * 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.Rlog; |
| |
| /** |
| * A holder for IRadioModem. |
| * Use getAidl to get IRadioModem and call the AIDL implementations of the HAL APIs. |
| */ |
| public class RadioModemProxy extends RadioServiceProxy { |
| private static final String TAG = "RadioModemProxy"; |
| private volatile android.hardware.radio.modem.IRadioModem mModemProxy = null; |
| |
| /** |
| * Set IRadioModem as the AIDL implementation for RadioServiceProxy |
| * @param halVersion Radio HAL version |
| * @param modem IRadioModem implementation |
| * |
| * @return updated HAL version |
| */ |
| public HalVersion setAidl(HalVersion halVersion, |
| android.hardware.radio.modem.IRadioModem modem) { |
| HalVersion version = halVersion; |
| try { |
| version = RIL.getServiceHalVersion(modem.getInterfaceVersion()); |
| } catch (RemoteException e) { |
| Rlog.e(TAG, "setAidl: " + e); |
| } |
| mHalVersion = version; |
| mModemProxy = modem; |
| mIsAidl = true; |
| |
| Rlog.d(TAG, "AIDL initialized mHalVersion=" + mHalVersion); |
| return mHalVersion; |
| } |
| |
| /** |
| * Get the AIDL implementation of RadioModemProxy |
| * @return IRadioModem implementation |
| */ |
| public android.hardware.radio.modem.IRadioModem getAidl() { |
| return mModemProxy; |
| } |
| |
| /** |
| * Reset RadioModemProxy |
| */ |
| @Override |
| public void clear() { |
| super.clear(); |
| mModemProxy = null; |
| } |
| |
| /** |
| * Check whether a RadioModem implementation exists |
| * @return true if there is neither a HIDL nor AIDL implementation |
| */ |
| @Override |
| public boolean isEmpty() { |
| return mRadioProxy == null && mModemProxy == null; |
| } |
| |
| /** |
| * Call IRadioModem#enableModem |
| * @param serial Serial number of request |
| * @param on Whether to enable or disable the modem |
| * @throws RemoteException |
| */ |
| public void enableModem(int serial, boolean on) throws RemoteException { |
| if (isEmpty()) return; |
| if (isAidl()) { |
| mModemProxy.enableModem(serial, on); |
| } else { |
| mRadioProxy.enableModem(serial, on); |
| } |
| } |
| |
| /** |
| * Call IRadioModem#getBasebandVersion |
| * @param serial Serial number of request |
| * @throws RemoteException |
| */ |
| public void getBasebandVersion(int serial) throws RemoteException { |
| if (isEmpty()) return; |
| if (isAidl()) { |
| mModemProxy.getBasebandVersion(serial); |
| } else { |
| mRadioProxy.getBasebandVersion(serial); |
| } |
| } |
| |
| /** |
| * Call IRadioModem#getDeviceIdentity |
| * @param serial Serial number of request |
| * @throws RemoteException |
| */ |
| public void getDeviceIdentity(int serial) throws RemoteException { |
| if (isEmpty()) return; |
| if (isAidl()) { |
| mModemProxy.getDeviceIdentity(serial); |
| } else { |
| mRadioProxy.getDeviceIdentity(serial); |
| } |
| } |
| |
| /** |
| * Call IRadioModem#getImei |
| * |
| * @param serial Serial number of request |
| * @throws RemoteException |
| */ |
| public void getImei(int serial) throws RemoteException { |
| if (isEmpty()) return; |
| if (isAidl()) { |
| mModemProxy.getImei(serial); |
| } |
| } |
| |
| /** |
| * Call IRadioModem#getHardwareConfig |
| * @param serial Serial number of request |
| * @throws RemoteException |
| */ |
| public void getHardwareConfig(int serial) throws RemoteException { |
| if (isEmpty()) return; |
| if (isAidl()) { |
| mModemProxy.getHardwareConfig(serial); |
| } else { |
| mRadioProxy.getHardwareConfig(serial); |
| } |
| } |
| |
| /** |
| * Call IRadioModem#getModemActivityInfo |
| * @param serial Serial number of request |
| * @throws RemoteException |
| */ |
| public void getModemActivityInfo(int serial) throws RemoteException { |
| if (isEmpty()) return; |
| if (isAidl()) { |
| mModemProxy.getModemActivityInfo(serial); |
| } else { |
| mRadioProxy.getModemActivityInfo(serial); |
| } |
| } |
| |
| /** |
| * Call IRadioModem#getModemStackStatus |
| * @param serial Serial number of request |
| * @throws RemoteException |
| */ |
| public void getModemStackStatus(int serial) throws RemoteException { |
| if (isEmpty()) return; |
| if (isAidl()) { |
| mModemProxy.getModemStackStatus(serial); |
| } else { |
| mRadioProxy.getModemStackStatus(serial); |
| } |
| } |
| |
| /** |
| * Call IRadioModem#getRadioCapability |
| * @param serial Serial number of request |
| * @throws RemoteException |
| */ |
| public void getRadioCapability(int serial) throws RemoteException { |
| if (isEmpty()) return; |
| if (isAidl()) { |
| mModemProxy.getRadioCapability(serial); |
| } else { |
| mRadioProxy.getRadioCapability(serial); |
| } |
| } |
| |
| /** |
| * Call IRadioModem#nvReadItem |
| * @param serial Serial number of request |
| * @param itemId ID of the item to read |
| * @throws RemoteException |
| */ |
| public void nvReadItem(int serial, int itemId) throws RemoteException { |
| if (isEmpty()) return; |
| if (isAidl()) { |
| mModemProxy.nvReadItem(serial, itemId); |
| } else { |
| mRadioProxy.nvReadItem(serial, itemId); |
| } |
| } |
| |
| /** |
| * Call IRadioModem#nvResetConfig |
| * @param serial Serial number of request |
| * @param resetType Reset type; 1: reload NV reset, 2: erase NV reset, 3: factory NV reset |
| * @throws RemoteException |
| */ |
| public void nvResetConfig(int serial, int resetType) throws RemoteException { |
| if (isEmpty()) return; |
| if (isAidl()) { |
| mModemProxy.nvResetConfig(serial, RILUtils.convertToHalResetNvTypeAidl(resetType)); |
| } else { |
| mRadioProxy.nvResetConfig(serial, RILUtils.convertToHalResetNvType(resetType)); |
| } |
| } |
| |
| /** |
| * Call IRadioModem#nvWriteCdmaPrl |
| * @param serial Serial number of request |
| * @param prl Preferred roaming list as a byte array |
| * @throws RemoteException |
| */ |
| public void nvWriteCdmaPrl(int serial, byte[] prl) throws RemoteException { |
| if (isEmpty()) return; |
| if (isAidl()) { |
| mModemProxy.nvWriteCdmaPrl(serial, prl); |
| } else { |
| mRadioProxy.nvWriteCdmaPrl(serial, RILUtils.primitiveArrayToArrayList(prl)); |
| } |
| } |
| |
| /** |
| * Call IRadioModem#nvWriteItem |
| * @param serial Serial number of request |
| * @param itemId ID of the item to write |
| * @param itemValue Value to write as a String |
| * @throws RemoteException |
| */ |
| public void nvWriteItem(int serial, int itemId, String itemValue) throws RemoteException { |
| if (isEmpty()) return; |
| if (isAidl()) { |
| android.hardware.radio.modem.NvWriteItem item = |
| new android.hardware.radio.modem.NvWriteItem(); |
| item.itemId = itemId; |
| item.value = itemValue; |
| mModemProxy.nvWriteItem(serial, item); |
| } else { |
| android.hardware.radio.V1_0.NvWriteItem item = |
| new android.hardware.radio.V1_0.NvWriteItem(); |
| item.itemId = itemId; |
| item.value = itemValue; |
| mRadioProxy.nvWriteItem(serial, item); |
| } |
| } |
| |
| /** |
| * Call IRadioModem#requestShutdown |
| * @param serial Serial number of request |
| * @throws RemoteException |
| */ |
| public void requestShutdown(int serial) throws RemoteException { |
| if (isEmpty()) return; |
| if (isAidl()) { |
| mModemProxy.requestShutdown(serial); |
| } else { |
| mRadioProxy.requestShutdown(serial); |
| } |
| } |
| |
| /** |
| * Call IRadioModem#responseAcknowledgement |
| * @throws RemoteException |
| */ |
| @Override |
| public void responseAcknowledgement() throws RemoteException { |
| if (isEmpty()) return; |
| if (isAidl()) { |
| mModemProxy.responseAcknowledgement(); |
| } else { |
| mRadioProxy.responseAcknowledgement(); |
| } |
| } |
| |
| /** |
| * Call IRadioModem#sendDeviceState |
| * @param serial Serial number of request |
| * @param deviceStateType Device state type |
| * @param state True if enabled and false if disabled |
| * @throws RemoteException |
| */ |
| public void sendDeviceState(int serial, int deviceStateType, boolean state) |
| throws RemoteException { |
| if (isEmpty()) return; |
| if (isAidl()) { |
| mModemProxy.sendDeviceState(serial, deviceStateType, state); |
| } else { |
| mRadioProxy.sendDeviceState(serial, deviceStateType, state); |
| } |
| } |
| |
| /** |
| * Call IRadioModem#setRadioCapability |
| * @param serial Serial number of request |
| * @param rc The phone radio capability defined in RadioCapability |
| * It's a input object used to transfer parameter to logic modem |
| * @throws RemoteException |
| */ |
| public void setRadioCapability(int serial, RadioCapability rc) throws RemoteException { |
| if (isEmpty()) return; |
| if (isAidl()) { |
| android.hardware.radio.modem.RadioCapability halRc = |
| new android.hardware.radio.modem.RadioCapability(); |
| halRc.session = rc.getSession(); |
| halRc.phase = rc.getPhase(); |
| halRc.raf = rc.getRadioAccessFamily(); |
| halRc.logicalModemUuid = RILUtils.convertNullToEmptyString(rc.getLogicalModemUuid()); |
| halRc.status = rc.getStatus(); |
| mModemProxy.setRadioCapability(serial, halRc); |
| } else { |
| android.hardware.radio.V1_0.RadioCapability halRc = |
| new android.hardware.radio.V1_0.RadioCapability(); |
| halRc.session = rc.getSession(); |
| halRc.phase = rc.getPhase(); |
| halRc.raf = rc.getRadioAccessFamily(); |
| halRc.logicalModemUuid = RILUtils.convertNullToEmptyString(rc.getLogicalModemUuid()); |
| halRc.status = rc.getStatus(); |
| mRadioProxy.setRadioCapability(serial, halRc); |
| } |
| } |
| |
| /** |
| * Call IRadioModem#setRadioPower |
| * @param serial Serial number of request |
| * @param powerOn True to turn on radio and false to turn off |
| * @param forEmergencyCall Indicates that this request is due to emergency call |
| * No effect if powerOn is false |
| * @param preferredForEmergencyCall Whether or not the following emergency call will be sent |
| * on this modem |
| * No effect if powerOn or forEmergencyCall is false |
| * @throws RemoteException |
| */ |
| public void setRadioPower(int serial, boolean powerOn, boolean forEmergencyCall, |
| boolean preferredForEmergencyCall) throws RemoteException { |
| if (isEmpty()) return; |
| if (isAidl()) { |
| mModemProxy.setRadioPower(serial, powerOn, forEmergencyCall, preferredForEmergencyCall); |
| } else if (mHalVersion.greaterOrEqual(RIL.RADIO_HAL_VERSION_1_6)) { |
| ((android.hardware.radio.V1_6.IRadio) mRadioProxy).setRadioPower_1_6(serial, powerOn, |
| forEmergencyCall, preferredForEmergencyCall); |
| } else if (mHalVersion.greaterOrEqual(RIL.RADIO_HAL_VERSION_1_5)) { |
| ((android.hardware.radio.V1_5.IRadio) mRadioProxy).setRadioPower_1_5(serial, powerOn, |
| forEmergencyCall, preferredForEmergencyCall); |
| } else { |
| mRadioProxy.setRadioPower(serial, powerOn); |
| } |
| } |
| } |
