564 lines
22 KiB
Java
564 lines
22 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;
|
|
|
|
import com.android.internal.telephony.cdma.CdmaSmsBroadcastConfigInfo;
|
|
import com.android.internal.telephony.gsm.SmsBroadcastConfigInfo;
|
|
|
|
import java.util.ArrayList;
|
|
|
|
/**
|
|
* A holder for IRadioMessaging.
|
|
* Use getAidl to get IRadioMessaging and call the AIDL implementations of the HAL APIs.
|
|
*/
|
|
public class RadioMessagingProxy extends RadioServiceProxy {
|
|
private static final String TAG = "RadioMessagingProxy";
|
|
private volatile android.hardware.radio.messaging.IRadioMessaging mMessagingProxy = null;
|
|
|
|
/**
|
|
* Set IRadioMessaging as the AIDL implementation for RadioServiceProxy
|
|
* @param halVersion Radio HAL version
|
|
* @param messaging IRadioMessaging implementation
|
|
*
|
|
* @return updated HAL version
|
|
*/
|
|
public HalVersion setAidl(HalVersion halVersion,
|
|
android.hardware.radio.messaging.IRadioMessaging messaging) {
|
|
HalVersion version = halVersion;
|
|
try {
|
|
version = RIL.getServiceHalVersion(messaging.getInterfaceVersion());
|
|
} catch (RemoteException e) {
|
|
Rlog.e(TAG, "setAidl: " + e);
|
|
}
|
|
mHalVersion = version;
|
|
mMessagingProxy = messaging;
|
|
mIsAidl = true;
|
|
|
|
Rlog.d(TAG, "AIDL initialized mHalVersion=" + mHalVersion);
|
|
return mHalVersion;
|
|
}
|
|
|
|
/**
|
|
* Get the AIDL implementation of RadioMessagingProxy
|
|
* @return IRadioMessaging implementation
|
|
*/
|
|
public android.hardware.radio.messaging.IRadioMessaging getAidl() {
|
|
return mMessagingProxy;
|
|
}
|
|
|
|
/**
|
|
* Reset RadioMessagingProxy
|
|
*/
|
|
@Override
|
|
public void clear() {
|
|
super.clear();
|
|
mMessagingProxy = null;
|
|
}
|
|
|
|
/**
|
|
* Check whether a RadioMessaging implementation exists
|
|
* @return true if there is neither a HIDL nor AIDL implementation
|
|
*/
|
|
@Override
|
|
public boolean isEmpty() {
|
|
return mRadioProxy == null && mMessagingProxy == null;
|
|
}
|
|
|
|
/**
|
|
* Call IRadioMessaging#acknowledgeIncomingGsmSmsWithPdu
|
|
* @param serial Serial number of request
|
|
* @param success True on successful receipt (RP-ACK) and false on failed receipt (RP-ERROR)
|
|
* @param ackPdu Acknowledgement TPDU in hexadecimal format
|
|
* @throws RemoteException
|
|
*/
|
|
public void acknowledgeIncomingGsmSmsWithPdu(int serial, boolean success, String ackPdu)
|
|
throws RemoteException {
|
|
if (isEmpty()) return;
|
|
if (isAidl()) {
|
|
mMessagingProxy.acknowledgeIncomingGsmSmsWithPdu(serial, success, ackPdu);
|
|
} else {
|
|
mRadioProxy.acknowledgeIncomingGsmSmsWithPdu(serial, success, ackPdu);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Calls IRadioMessaging#acknowledgeLastIncomingCdmaSms
|
|
* @param serial Serial number of request
|
|
* @param success True on successful receipt
|
|
* @param cause Failure cause if success is false
|
|
* @throws RemoteException
|
|
*/
|
|
public void acknowledgeLastIncomingCdmaSms(int serial, boolean success, int cause)
|
|
throws RemoteException {
|
|
if (isEmpty()) return;
|
|
if (isAidl()) {
|
|
android.hardware.radio.messaging.CdmaSmsAck msg =
|
|
new android.hardware.radio.messaging.CdmaSmsAck();
|
|
msg.errorClass = success;
|
|
msg.smsCauseCode = cause;
|
|
mMessagingProxy.acknowledgeLastIncomingCdmaSms(serial, msg);
|
|
} else {
|
|
android.hardware.radio.V1_0.CdmaSmsAck msg =
|
|
new android.hardware.radio.V1_0.CdmaSmsAck();
|
|
msg.errorClass = success ? 0 : 1;
|
|
msg.smsCauseCode = cause;
|
|
mRadioProxy.acknowledgeLastIncomingCdmaSms(serial, msg);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Calls IRadioMessaging#acknowledgeLastIncomingGsmSms
|
|
* @param serial Serial number of request
|
|
* @param success True on successful receipt
|
|
* @param cause Failure cause if success is false
|
|
* @throws RemoteException
|
|
*/
|
|
public void acknowledgeLastIncomingGsmSms(int serial, boolean success, int cause)
|
|
throws RemoteException {
|
|
if (isEmpty()) return;
|
|
if (isAidl()) {
|
|
mMessagingProxy.acknowledgeLastIncomingGsmSms(serial, success, cause);
|
|
} else {
|
|
mRadioProxy.acknowledgeLastIncomingGsmSms(serial, success, cause);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Call IRadioMessaging#deleteSmsOnRuim
|
|
* @param serial Serial number of request
|
|
* @param index Record index of the message to delete
|
|
* @throws RemoteException
|
|
*/
|
|
public void deleteSmsOnRuim(int serial, int index) throws RemoteException {
|
|
if (isEmpty()) return;
|
|
if (isAidl()) {
|
|
mMessagingProxy.deleteSmsOnRuim(serial, index);
|
|
} else {
|
|
mRadioProxy.deleteSmsOnRuim(serial, index);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Call IRadioMessaging#deleteSmsOnSim
|
|
* @param serial Serial number of request
|
|
* @param index Record index of the message to delete
|
|
* @throws RemoteException
|
|
*/
|
|
public void deleteSmsOnSim(int serial, int index) throws RemoteException {
|
|
if (isEmpty()) return;
|
|
if (isAidl()) {
|
|
mMessagingProxy.deleteSmsOnSim(serial, index);
|
|
} else {
|
|
mRadioProxy.deleteSmsOnSim(serial, index);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Call IRadioMessaging#getCdmaBroadcastConfig
|
|
* @param serial Serial number of request
|
|
* @throws RemoteException
|
|
*/
|
|
public void getCdmaBroadcastConfig(int serial) throws RemoteException {
|
|
if (isEmpty()) return;
|
|
if (isAidl()) {
|
|
mMessagingProxy.getCdmaBroadcastConfig(serial);
|
|
} else {
|
|
mRadioProxy.getCdmaBroadcastConfig(serial);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Call IRadioMessaging#getGsmBroadcastConfig
|
|
* @param serial Serial number of request
|
|
* @throws RemoteException
|
|
*/
|
|
public void getGsmBroadcastConfig(int serial) throws RemoteException {
|
|
if (isEmpty()) return;
|
|
if (isAidl()) {
|
|
mMessagingProxy.getGsmBroadcastConfig(serial);
|
|
} else {
|
|
mRadioProxy.getGsmBroadcastConfig(serial);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Call IRadioMessaging#getSmscAddress
|
|
* @param serial Serial number of request
|
|
* @throws RemoteException
|
|
*/
|
|
public void getSmscAddress(int serial) throws RemoteException {
|
|
if (isEmpty()) return;
|
|
if (isAidl()) {
|
|
mMessagingProxy.getSmscAddress(serial);
|
|
} else {
|
|
mRadioProxy.getSmscAddress(serial);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Call IRadioMessaging#reportSmsMemoryStatus
|
|
* @param serial Serial number of request
|
|
* @param available Whether or not storage is available
|
|
* @throws RemoteException
|
|
*/
|
|
public void reportSmsMemoryStatus(int serial, boolean available) throws RemoteException {
|
|
if (isEmpty()) return;
|
|
if (isAidl()) {
|
|
mMessagingProxy.reportSmsMemoryStatus(serial, available);
|
|
} else {
|
|
mRadioProxy.reportSmsMemoryStatus(serial, available);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Call IRadioMessaging#responseAcknowledgement
|
|
* @throws RemoteException
|
|
*/
|
|
@Override
|
|
public void responseAcknowledgement() throws RemoteException {
|
|
if (isEmpty()) return;
|
|
if (isAidl()) {
|
|
mMessagingProxy.responseAcknowledgement();
|
|
} else {
|
|
mRadioProxy.responseAcknowledgement();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Call IRadioMessaging#sendCdmaSms
|
|
* @param serial Serial number of request
|
|
* @param pdu CDMA-SMS in internal pseudo-PDU format
|
|
* @throws RemoteException
|
|
*/
|
|
public void sendCdmaSms(int serial, byte[] pdu) throws RemoteException {
|
|
if (isEmpty()) return;
|
|
if (isAidl()) {
|
|
mMessagingProxy.sendCdmaSms(serial, RILUtils.convertToHalCdmaSmsMessageAidl(pdu));
|
|
} else if (mHalVersion.greaterOrEqual(RIL.RADIO_HAL_VERSION_1_6)) {
|
|
((android.hardware.radio.V1_6.IRadio) mRadioProxy).sendCdmaSms_1_6(
|
|
serial, RILUtils.convertToHalCdmaSmsMessage(pdu));
|
|
} else {
|
|
mRadioProxy.sendCdmaSms(serial, RILUtils.convertToHalCdmaSmsMessage(pdu));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Call IRadioMessaging#sendCdmaSmsExpectMore
|
|
* @param serial Serial number of request
|
|
* @param pdu CDMA-SMS in internal pseudo-PDU format
|
|
* @throws RemoteException
|
|
*/
|
|
public void sendCdmaSmsExpectMore(int serial, byte[] pdu) throws RemoteException {
|
|
if (isEmpty()) return;
|
|
if (isAidl()) {
|
|
mMessagingProxy.sendCdmaSmsExpectMore(
|
|
serial, RILUtils.convertToHalCdmaSmsMessageAidl(pdu));
|
|
} else if (mHalVersion.greaterOrEqual(RIL.RADIO_HAL_VERSION_1_6)) {
|
|
((android.hardware.radio.V1_6.IRadio) mRadioProxy).sendCdmaSmsExpectMore_1_6(
|
|
serial, RILUtils.convertToHalCdmaSmsMessage(pdu));
|
|
} else if (mHalVersion.greaterOrEqual(RIL.RADIO_HAL_VERSION_1_5)) {
|
|
((android.hardware.radio.V1_5.IRadio) mRadioProxy).sendCdmaSmsExpectMore(
|
|
serial, RILUtils.convertToHalCdmaSmsMessage(pdu));
|
|
} else {
|
|
mRadioProxy.sendCdmaSms(serial, RILUtils.convertToHalCdmaSmsMessage(pdu));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Call IRadioMessaging#sendImsSms
|
|
* @param serial Serial number of request
|
|
* @param smscPdu SMSC address in PDU form GSM BCD format prefixed by a length byte
|
|
* or NULL for default SMSC
|
|
* @param gsmPdu SMS in PDU format as an ASCII hex string less the SMSC address
|
|
* @param cdmaPdu CDMA-SMS in internal pseudo-PDU format
|
|
* @param retry Whether this is a retry; 0 == not retry, nonzero = retry
|
|
* @param messageRef MessageRef from RIL_SMS_RESPONSE corresponding to failed MO SMS
|
|
* if retry is nonzero
|
|
* @throws RemoteException
|
|
*/
|
|
public void sendImsSms(int serial, String smscPdu, String gsmPdu, byte[] cdmaPdu, int retry,
|
|
int messageRef) throws RemoteException {
|
|
if (isEmpty()) return;
|
|
if (isAidl()) {
|
|
android.hardware.radio.messaging.ImsSmsMessage msg =
|
|
new android.hardware.radio.messaging.ImsSmsMessage();
|
|
msg.tech = android.hardware.radio.RadioTechnologyFamily.THREE_GPP;
|
|
msg.retry = (byte) retry >= 1;
|
|
msg.messageRef = messageRef;
|
|
if (gsmPdu != null) {
|
|
msg.gsmMessage = new android.hardware.radio.messaging.GsmSmsMessage[]{
|
|
RILUtils.convertToHalGsmSmsMessageAidl(smscPdu, gsmPdu)};
|
|
msg.cdmaMessage = new android.hardware.radio.messaging.CdmaSmsMessage[0];
|
|
}
|
|
if (cdmaPdu != null) {
|
|
msg.gsmMessage = new android.hardware.radio.messaging.GsmSmsMessage[0];
|
|
msg.cdmaMessage = new android.hardware.radio.messaging.CdmaSmsMessage[]{
|
|
RILUtils.convertToHalCdmaSmsMessageAidl(cdmaPdu)};
|
|
}
|
|
mMessagingProxy.sendImsSms(serial, msg);
|
|
} else {
|
|
android.hardware.radio.V1_0.ImsSmsMessage msg =
|
|
new android.hardware.radio.V1_0.ImsSmsMessage();
|
|
msg.tech = android.hardware.radio.V1_0.RadioTechnologyFamily.THREE_GPP;
|
|
msg.retry = (byte) retry >= 1;
|
|
msg.messageRef = messageRef;
|
|
if (gsmPdu != null) {
|
|
msg.gsmMessage.add(RILUtils.convertToHalGsmSmsMessage(smscPdu, gsmPdu));
|
|
}
|
|
if (cdmaPdu != null) {
|
|
msg.cdmaMessage.add(RILUtils.convertToHalCdmaSmsMessage(cdmaPdu));
|
|
}
|
|
mRadioProxy.sendImsSms(serial, msg);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Call IRadioMessaging#sendSms
|
|
* @param serial Serial number of request
|
|
* @param smscPdu SMSC address in PDU form GSM BCD format prefixed by a length byte
|
|
* or NULL for default SMSC
|
|
* @param pdu SMS in PDU format as an ASCII hex string less the SMSC address
|
|
* @throws RemoteException
|
|
*/
|
|
public void sendSms(int serial, String smscPdu, String pdu) throws RemoteException {
|
|
if (isEmpty()) return;
|
|
if (isAidl()) {
|
|
mMessagingProxy.sendSms(serial, RILUtils.convertToHalGsmSmsMessageAidl(smscPdu, pdu));
|
|
} else if (mHalVersion.greaterOrEqual(RIL.RADIO_HAL_VERSION_1_6)) {
|
|
((android.hardware.radio.V1_6.IRadio) mRadioProxy).sendSms_1_6(
|
|
serial, RILUtils.convertToHalGsmSmsMessage(smscPdu, pdu));
|
|
} else {
|
|
mRadioProxy.sendSms(serial, RILUtils.convertToHalGsmSmsMessage(smscPdu, pdu));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Call IRadioMessaging#sendSmsExpectMore
|
|
* @param serial Serial number of request
|
|
* @param smscPdu SMSC address in PDU form GSM BCD format prefixed by a length byte
|
|
* or NULL for default SMSC
|
|
* @param pdu SMS in PDU format as an ASCII hex string less the SMSC address
|
|
* @throws RemoteException
|
|
*/
|
|
public void sendSmsExpectMore(int serial, String smscPdu, String pdu) throws RemoteException {
|
|
if (isEmpty()) return;
|
|
if (isAidl()) {
|
|
mMessagingProxy.sendSmsExpectMore(serial,
|
|
RILUtils.convertToHalGsmSmsMessageAidl(smscPdu, pdu));
|
|
} else if (mHalVersion.greaterOrEqual(RIL.RADIO_HAL_VERSION_1_6)) {
|
|
((android.hardware.radio.V1_6.IRadio) mRadioProxy).sendSmsExpectMore_1_6(serial,
|
|
RILUtils.convertToHalGsmSmsMessage(smscPdu, pdu));
|
|
} else {
|
|
mRadioProxy.sendSMSExpectMore(serial, RILUtils.convertToHalGsmSmsMessage(smscPdu, pdu));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Call IRadioMessaging#setCdmaBroadcastActivation
|
|
* @param serial Serial number of request
|
|
* @param activate Whether to activate or turn off the reception of CDMA Cell Broadcast SMS;
|
|
* true = activate, false = turn off
|
|
* @throws RemoteException
|
|
*/
|
|
public void setCdmaBroadcastActivation(int serial, boolean activate) throws RemoteException {
|
|
if (isEmpty()) return;
|
|
if (isAidl()) {
|
|
mMessagingProxy.setCdmaBroadcastActivation(serial, activate);
|
|
} else {
|
|
mRadioProxy.setCdmaBroadcastActivation(serial, activate);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Call IRadioMessaging#setCdmaBroadcastConfig
|
|
* @param serial Serial number of request
|
|
* @param configs Setting of CDMA cell broadcast config
|
|
* @throws RemoteException
|
|
*/
|
|
public void setCdmaBroadcastConfig(int serial, CdmaSmsBroadcastConfigInfo[] configs)
|
|
throws RemoteException {
|
|
if (isEmpty()) return;
|
|
if (isAidl()) {
|
|
ArrayList<android.hardware.radio.messaging.CdmaBroadcastSmsConfigInfo> halConfigs =
|
|
new ArrayList<>();
|
|
for (CdmaSmsBroadcastConfigInfo config: configs) {
|
|
for (int i = config.getFromServiceCategory(); i <= config.getToServiceCategory();
|
|
i++) {
|
|
android.hardware.radio.messaging.CdmaBroadcastSmsConfigInfo info =
|
|
new android.hardware.radio.messaging.CdmaBroadcastSmsConfigInfo();
|
|
info.serviceCategory = i;
|
|
info.language = config.getLanguage();
|
|
info.selected = config.isSelected();
|
|
halConfigs.add(info);
|
|
}
|
|
}
|
|
mMessagingProxy.setCdmaBroadcastConfig(serial, halConfigs.stream().toArray(
|
|
android.hardware.radio.messaging.CdmaBroadcastSmsConfigInfo[]::new));
|
|
} else {
|
|
ArrayList<android.hardware.radio.V1_0.CdmaBroadcastSmsConfigInfo> halConfigs =
|
|
new ArrayList<>();
|
|
for (CdmaSmsBroadcastConfigInfo config: configs) {
|
|
for (int i = config.getFromServiceCategory(); i <= config.getToServiceCategory();
|
|
i++) {
|
|
android.hardware.radio.V1_0.CdmaBroadcastSmsConfigInfo info =
|
|
new android.hardware.radio.V1_0.CdmaBroadcastSmsConfigInfo();
|
|
info.serviceCategory = i;
|
|
info.language = config.getLanguage();
|
|
info.selected = config.isSelected();
|
|
halConfigs.add(info);
|
|
}
|
|
}
|
|
mRadioProxy.setCdmaBroadcastConfig(serial, halConfigs);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Call IRadioMessaging#setGsmBroadcastActivation
|
|
* @param serial Serial number of request
|
|
* @param activate Whether to activate or turn off the reception of GSM/WCDMA Cell Broadcast
|
|
* SMS; true = activate, false = turn off
|
|
* @throws RemoteException
|
|
*/
|
|
public void setGsmBroadcastActivation(int serial, boolean activate) throws RemoteException {
|
|
if (isEmpty()) return;
|
|
if (isAidl()) {
|
|
mMessagingProxy.setGsmBroadcastActivation(serial, activate);
|
|
} else {
|
|
mRadioProxy.setGsmBroadcastActivation(serial, activate);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Call IRadioMessaging#setGsmBroadcastConfig
|
|
* @param serial Serial number of request
|
|
* @param configInfo Setting of GSM/WCDMA cell broadcast config
|
|
* @throws RemoteException
|
|
*/
|
|
public void setGsmBroadcastConfig(int serial, SmsBroadcastConfigInfo[] configInfo)
|
|
throws RemoteException {
|
|
if (isEmpty()) return;
|
|
if (isAidl()) {
|
|
android.hardware.radio.messaging.GsmBroadcastSmsConfigInfo[] configs =
|
|
new android.hardware.radio.messaging.GsmBroadcastSmsConfigInfo[
|
|
configInfo.length];
|
|
android.hardware.radio.messaging.GsmBroadcastSmsConfigInfo info;
|
|
for (int i = 0; i < configInfo.length; i++) {
|
|
info = new android.hardware.radio.messaging.GsmBroadcastSmsConfigInfo();
|
|
info.fromServiceId = configInfo[i].getFromServiceId();
|
|
info.toServiceId = configInfo[i].getToServiceId();
|
|
info.fromCodeScheme = configInfo[i].getFromCodeScheme();
|
|
info.toCodeScheme = configInfo[i].getToCodeScheme();
|
|
info.selected = configInfo[i].isSelected();
|
|
configs[i] = info;
|
|
}
|
|
mMessagingProxy.setGsmBroadcastConfig(serial, configs);
|
|
} else {
|
|
ArrayList<android.hardware.radio.V1_0.GsmBroadcastSmsConfigInfo> configs =
|
|
new ArrayList<>();
|
|
android.hardware.radio.V1_0.GsmBroadcastSmsConfigInfo info;
|
|
for (int i = 0; i < configInfo.length; i++) {
|
|
info = new android.hardware.radio.V1_0.GsmBroadcastSmsConfigInfo();
|
|
info.fromServiceId = configInfo[i].getFromServiceId();
|
|
info.toServiceId = configInfo[i].getToServiceId();
|
|
info.fromCodeScheme = configInfo[i].getFromCodeScheme();
|
|
info.toCodeScheme = configInfo[i].getToCodeScheme();
|
|
info.selected = configInfo[i].isSelected();
|
|
configs.add(info);
|
|
}
|
|
mRadioProxy.setGsmBroadcastConfig(serial, configs);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Call IRadioMessaging#setSmscAddress
|
|
* @param serial Serial number of request
|
|
* @param smsc Short Message Service Center address to set
|
|
* @throws RemoteException
|
|
*/
|
|
public void setSmscAddress(int serial, String smsc) throws RemoteException {
|
|
if (isEmpty()) return;
|
|
if (isAidl()) {
|
|
mMessagingProxy.setSmscAddress(serial, smsc);
|
|
} else {
|
|
mRadioProxy.setSmscAddress(serial, smsc);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Call IRadioMessaging#writeSmsToRuim
|
|
* @param serial Serial number of request
|
|
* @param status Status of message on SIM. One of:
|
|
* SmsManager.STATUS_ON_ICC_READ
|
|
* SmsManager.STATUS_ON_ICC_UNREAD
|
|
* SmsManager.STATUS_ON_ICC_SENT
|
|
* SmsManager.STATUS_ON_ICC_UNSENT
|
|
* @param pdu SMS in PDU format as a byte array
|
|
* @throws RemoteException
|
|
*/
|
|
public void writeSmsToRuim(int serial, int status, byte[] pdu) throws RemoteException {
|
|
if (isEmpty()) return;
|
|
if (isAidl()) {
|
|
android.hardware.radio.messaging.CdmaSmsWriteArgs args =
|
|
new android.hardware.radio.messaging.CdmaSmsWriteArgs();
|
|
args.status = RILUtils.convertToHalSmsWriteArgsStatusAidl(status);
|
|
args.message = RILUtils.convertToHalCdmaSmsMessageAidl(pdu);
|
|
mMessagingProxy.writeSmsToRuim(serial, args);
|
|
} else {
|
|
android.hardware.radio.V1_0.CdmaSmsWriteArgs args =
|
|
new android.hardware.radio.V1_0.CdmaSmsWriteArgs();
|
|
args.status = RILUtils.convertToHalSmsWriteArgsStatus(status);
|
|
args.message = RILUtils.convertToHalCdmaSmsMessage(pdu);
|
|
mRadioProxy.writeSmsToRuim(serial, args);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Call IRadioMessaging#writeSmsToSim
|
|
* @param serial Serial number of request
|
|
* @param status Status of message on SIM. One of:
|
|
* SmsManager.STATUS_ON_ICC_READ
|
|
* SmsManager.STATUS_ON_ICC_UNREAD
|
|
* SmsManager.STATUS_ON_ICC_SENT
|
|
* SmsManager.STATUS_ON_ICC_UNSENT
|
|
* @param smsc SMSC address
|
|
* @param pdu SMS in PDU format as an ASCII hex string less the SMSC address
|
|
* @throws RemoteException
|
|
*/
|
|
public void writeSmsToSim(int serial, int status, String smsc, String pdu)
|
|
throws RemoteException {
|
|
if (isEmpty()) return;
|
|
if (isAidl()) {
|
|
android.hardware.radio.messaging.SmsWriteArgs args =
|
|
new android.hardware.radio.messaging.SmsWriteArgs();
|
|
args.status = RILUtils.convertToHalSmsWriteArgsStatusAidl(status);
|
|
args.smsc = smsc;
|
|
args.pdu = pdu;
|
|
mMessagingProxy.writeSmsToSim(serial, args);
|
|
} else {
|
|
android.hardware.radio.V1_0.SmsWriteArgs args =
|
|
new android.hardware.radio.V1_0.SmsWriteArgs();
|
|
args.status = RILUtils.convertToHalSmsWriteArgsStatus(status);
|
|
args.smsc = smsc;
|
|
args.pdu = pdu;
|
|
mRadioProxy.writeSmsToSim(serial, args);
|
|
}
|
|
}
|
|
}
|