362 lines
12 KiB
Java
362 lines
12 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.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);
|
|
}
|
|
}
|
|
}
|