458 lines
21 KiB
Java
458 lines
21 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 static android.telephony.TelephonyManager.HAL_SERVICE_VOICE;
|
|
|
|
import static com.android.internal.telephony.RILConstants.RIL_UNSOL_CALL_RING;
|
|
import static com.android.internal.telephony.RILConstants.RIL_UNSOL_CDMA_CALL_WAITING;
|
|
import static com.android.internal.telephony.RILConstants.RIL_UNSOL_CDMA_INFO_REC;
|
|
import static com.android.internal.telephony.RILConstants.RIL_UNSOL_CDMA_OTA_PROVISION_STATUS;
|
|
import static com.android.internal.telephony.RILConstants.RIL_UNSOL_EMERGENCY_NUMBER_LIST;
|
|
import static com.android.internal.telephony.RILConstants.RIL_UNSOL_ENTER_EMERGENCY_CALLBACK_MODE;
|
|
import static com.android.internal.telephony.RILConstants.RIL_UNSOL_EXIT_EMERGENCY_CALLBACK_MODE;
|
|
import static com.android.internal.telephony.RILConstants.RIL_UNSOL_ON_SS;
|
|
import static com.android.internal.telephony.RILConstants.RIL_UNSOL_ON_USSD;
|
|
import static com.android.internal.telephony.RILConstants.RIL_UNSOL_RESEND_INCALL_MUTE;
|
|
import static com.android.internal.telephony.RILConstants.RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED;
|
|
import static com.android.internal.telephony.RILConstants.RIL_UNSOL_RINGBACK_TONE;
|
|
import static com.android.internal.telephony.RILConstants.RIL_UNSOL_SRVCC_STATE_NOTIFY;
|
|
import static com.android.internal.telephony.RILConstants.RIL_UNSOL_STK_CALL_SETUP;
|
|
import static com.android.internal.telephony.RILConstants.RIL_UNSOL_STK_CC_ALPHA_NOTIFY;
|
|
|
|
import android.hardware.radio.voice.IRadioVoiceIndication;
|
|
import android.os.AsyncResult;
|
|
import android.telephony.emergency.EmergencyNumber;
|
|
|
|
import com.android.internal.telephony.cdma.CdmaCallWaitingNotification;
|
|
import com.android.internal.telephony.cdma.CdmaInformationRecords;
|
|
import com.android.internal.telephony.gsm.SsData;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.List;
|
|
|
|
/**
|
|
* Interface declaring unsolicited radio indications for voice APIs.
|
|
*/
|
|
public class VoiceIndication extends IRadioVoiceIndication.Stub {
|
|
private final RIL mRil;
|
|
|
|
public VoiceIndication(RIL ril) {
|
|
mRil = ril;
|
|
}
|
|
|
|
/**
|
|
* Ring indication for an incoming call (eg, RING or CRING event).
|
|
* The rate of these events is controlled by ro.telephony.call_ring.delay and has a default
|
|
* value of 3000 (3 seconds) if absent.
|
|
* @param indicationType Type of radio indication
|
|
* @param isGsm true for GSM & false for CDMA
|
|
* @param record CDMA signal information record
|
|
*/
|
|
public void callRing(int indicationType, boolean isGsm,
|
|
android.hardware.radio.voice.CdmaSignalInfoRecord record) {
|
|
mRil.processIndication(HAL_SERVICE_VOICE, indicationType);
|
|
|
|
char[] response = null;
|
|
|
|
// Ignore record for gsm
|
|
if (!isGsm) {
|
|
// TODO: Clean this up with a parcelable class for better self-documentation
|
|
response = new char[4];
|
|
response[0] = (char) (record.isPresent ? 1 : 0);
|
|
response[1] = (char) record.signalType;
|
|
response[2] = (char) record.alertPitch;
|
|
response[3] = (char) record.signal;
|
|
mRil.writeMetricsCallRing(response);
|
|
}
|
|
|
|
if (mRil.isLogOrTrace()) mRil.unsljLogRet(RIL_UNSOL_CALL_RING, response);
|
|
|
|
if (mRil.mRingRegistrant != null) {
|
|
mRil.mRingRegistrant.notifyRegistrant(new AsyncResult(null, response, null));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Indicates when call state has changed. Redundant or extraneous invocations are tolerated.
|
|
* @param indicationType Type of radio indication
|
|
*/
|
|
public void callStateChanged(int indicationType) {
|
|
mRil.processIndication(HAL_SERVICE_VOICE, indicationType);
|
|
|
|
if (mRil.isLogOrTrace()) mRil.unsljLog(RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED);
|
|
|
|
mRil.mCallStateRegistrants.notifyRegistrants();
|
|
}
|
|
|
|
/**
|
|
* Indicates when CDMA radio receives a call waiting indication.
|
|
* @param indicationType Type of radio indication
|
|
* @param callWaitingRecord Cdma CallWaiting information
|
|
*/
|
|
public void cdmaCallWaiting(int indicationType,
|
|
android.hardware.radio.voice.CdmaCallWaiting callWaitingRecord) {
|
|
mRil.processIndication(HAL_SERVICE_VOICE, indicationType);
|
|
|
|
// TODO: create a CdmaCallWaitingNotification constructor that takes in these fields to make
|
|
// sure no fields are missing
|
|
CdmaCallWaitingNotification notification = new CdmaCallWaitingNotification();
|
|
notification.number = callWaitingRecord.number;
|
|
notification.numberPresentation = CdmaCallWaitingNotification.presentationFromCLIP(
|
|
callWaitingRecord.numberPresentation);
|
|
notification.name = callWaitingRecord.name;
|
|
notification.namePresentation = notification.numberPresentation;
|
|
notification.isPresent = callWaitingRecord.signalInfoRecord.isPresent ? 1 : 0;
|
|
notification.signalType = callWaitingRecord.signalInfoRecord.signalType;
|
|
notification.alertPitch = callWaitingRecord.signalInfoRecord.alertPitch;
|
|
notification.signal = callWaitingRecord.signalInfoRecord.signal;
|
|
notification.numberType = callWaitingRecord.numberType;
|
|
notification.numberPlan = callWaitingRecord.numberPlan;
|
|
|
|
if (mRil.isLogOrTrace()) mRil.unsljLogRet(RIL_UNSOL_CDMA_CALL_WAITING, notification);
|
|
|
|
mRil.mCallWaitingInfoRegistrants.notifyRegistrants(
|
|
new AsyncResult(null, notification, null));
|
|
}
|
|
|
|
/**
|
|
* Indicates when CDMA radio receives one or more info recs.
|
|
* @param indicationType Type of radio indication
|
|
* @param records New CDMA information
|
|
*/
|
|
public void cdmaInfoRec(int indicationType,
|
|
android.hardware.radio.voice.CdmaInformationRecord[] records) {
|
|
mRil.processIndication(HAL_SERVICE_VOICE, indicationType);
|
|
|
|
for (int i = 0; i < records.length; i++) {
|
|
android.hardware.radio.voice.CdmaInformationRecord record = records[i];
|
|
int id = record.name;
|
|
CdmaInformationRecords cdmaInformationRecords;
|
|
switch (id) {
|
|
case CdmaInformationRecords.RIL_CDMA_DISPLAY_INFO_REC:
|
|
case CdmaInformationRecords.RIL_CDMA_EXTENDED_DISPLAY_INFO_REC:
|
|
CdmaInformationRecords.CdmaDisplayInfoRec cdmaDisplayInfoRec =
|
|
new CdmaInformationRecords.CdmaDisplayInfoRec(id,
|
|
record.display[0].alphaBuf);
|
|
cdmaInformationRecords = new CdmaInformationRecords(cdmaDisplayInfoRec);
|
|
break;
|
|
|
|
case CdmaInformationRecords.RIL_CDMA_CALLED_PARTY_NUMBER_INFO_REC:
|
|
case CdmaInformationRecords.RIL_CDMA_CALLING_PARTY_NUMBER_INFO_REC:
|
|
case CdmaInformationRecords.RIL_CDMA_CONNECTED_NUMBER_INFO_REC:
|
|
android.hardware.radio.voice.CdmaNumberInfoRecord numInfoRecord =
|
|
record.number[0];
|
|
CdmaInformationRecords.CdmaNumberInfoRec cdmaNumberInfoRec =
|
|
new CdmaInformationRecords.CdmaNumberInfoRec(id, numInfoRecord.number,
|
|
numInfoRecord.numberType, numInfoRecord.numberPlan,
|
|
numInfoRecord.pi, numInfoRecord.si);
|
|
cdmaInformationRecords = new CdmaInformationRecords(cdmaNumberInfoRec);
|
|
break;
|
|
|
|
case CdmaInformationRecords.RIL_CDMA_SIGNAL_INFO_REC:
|
|
android.hardware.radio.voice.CdmaSignalInfoRecord signalInfoRecord =
|
|
record.signal[0];
|
|
CdmaInformationRecords.CdmaSignalInfoRec cdmaSignalInfoRec =
|
|
new CdmaInformationRecords.CdmaSignalInfoRec(
|
|
signalInfoRecord.isPresent ? 1 : 0, signalInfoRecord.signalType,
|
|
signalInfoRecord.alertPitch, signalInfoRecord.signal);
|
|
cdmaInformationRecords = new CdmaInformationRecords(cdmaSignalInfoRec);
|
|
break;
|
|
|
|
case CdmaInformationRecords.RIL_CDMA_REDIRECTING_NUMBER_INFO_REC:
|
|
android.hardware.radio.voice.CdmaRedirectingNumberInfoRecord
|
|
redirectingNumberInfoRecord = record.redir[0];
|
|
CdmaInformationRecords.CdmaRedirectingNumberInfoRec
|
|
cdmaRedirectingNumberInfoRec =
|
|
new CdmaInformationRecords.CdmaRedirectingNumberInfoRec(
|
|
redirectingNumberInfoRecord.redirectingNumber.number,
|
|
redirectingNumberInfoRecord.redirectingNumber.numberType,
|
|
redirectingNumberInfoRecord.redirectingNumber.numberPlan,
|
|
redirectingNumberInfoRecord.redirectingNumber.pi,
|
|
redirectingNumberInfoRecord.redirectingNumber.si,
|
|
redirectingNumberInfoRecord.redirectingReason);
|
|
cdmaInformationRecords = new CdmaInformationRecords(
|
|
cdmaRedirectingNumberInfoRec);
|
|
break;
|
|
|
|
case CdmaInformationRecords.RIL_CDMA_LINE_CONTROL_INFO_REC:
|
|
android.hardware.radio.voice.CdmaLineControlInfoRecord lineControlInfoRecord =
|
|
record.lineCtrl[0];
|
|
CdmaInformationRecords.CdmaLineControlInfoRec cdmaLineControlInfoRec =
|
|
new CdmaInformationRecords.CdmaLineControlInfoRec(
|
|
lineControlInfoRecord.lineCtrlPolarityIncluded,
|
|
lineControlInfoRecord.lineCtrlToggle,
|
|
lineControlInfoRecord.lineCtrlReverse,
|
|
lineControlInfoRecord.lineCtrlPowerDenial);
|
|
cdmaInformationRecords = new CdmaInformationRecords(cdmaLineControlInfoRec);
|
|
break;
|
|
|
|
case CdmaInformationRecords.RIL_CDMA_T53_CLIR_INFO_REC:
|
|
CdmaInformationRecords.CdmaT53ClirInfoRec cdmaT53ClirInfoRec =
|
|
new CdmaInformationRecords.CdmaT53ClirInfoRec(record.clir[0].cause);
|
|
cdmaInformationRecords = new CdmaInformationRecords(cdmaT53ClirInfoRec);
|
|
break;
|
|
|
|
case CdmaInformationRecords.RIL_CDMA_T53_AUDIO_CONTROL_INFO_REC:
|
|
android.hardware.radio.voice.CdmaT53AudioControlInfoRecord
|
|
audioControlInfoRecord = record.audioCtrl[0];
|
|
CdmaInformationRecords.CdmaT53AudioControlInfoRec cdmaT53AudioControlInfoRec =
|
|
new CdmaInformationRecords.CdmaT53AudioControlInfoRec(
|
|
audioControlInfoRecord.upLink,
|
|
audioControlInfoRecord.downLink);
|
|
cdmaInformationRecords = new CdmaInformationRecords(cdmaT53AudioControlInfoRec);
|
|
break;
|
|
|
|
default:
|
|
throw new RuntimeException("RIL_UNSOL_CDMA_INFO_REC: unsupported record. Got "
|
|
+ CdmaInformationRecords.idToString(id) + " ");
|
|
}
|
|
|
|
if (mRil.isLogOrTrace()) {
|
|
mRil.unsljLogRet(RIL_UNSOL_CDMA_INFO_REC, cdmaInformationRecords);
|
|
}
|
|
mRil.notifyRegistrantsCdmaInfoRec(cdmaInformationRecords);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Indicates when CDMA radio receives an update of the progress of an OTASP/OTAPA call.
|
|
* @param indicationType Type of radio indication
|
|
* @param status CDMA OTA provision status
|
|
*/
|
|
public void cdmaOtaProvisionStatus(int indicationType, int status) {
|
|
mRil.processIndication(HAL_SERVICE_VOICE, indicationType);
|
|
|
|
int[] response = new int[] {status};
|
|
|
|
if (mRil.isLogOrTrace()) {
|
|
mRil.unsljLogRet(RIL_UNSOL_CDMA_OTA_PROVISION_STATUS, response);
|
|
}
|
|
|
|
mRil.mOtaProvisionRegistrants.notifyRegistrants(new AsyncResult(null, response, null));
|
|
}
|
|
|
|
|
|
/**
|
|
* Indicates current emergency number list.
|
|
* @param indicationType Type of radio indication
|
|
* @param emergencyNumberList Current list of emergency numbers known to radio
|
|
*/
|
|
public void currentEmergencyNumberList(int indicationType,
|
|
android.hardware.radio.voice.EmergencyNumber[] emergencyNumberList) {
|
|
mRil.processIndication(HAL_SERVICE_VOICE, indicationType);
|
|
|
|
List<EmergencyNumber> response = new ArrayList<>(emergencyNumberList.length);
|
|
for (android.hardware.radio.voice.EmergencyNumber enHal : emergencyNumberList) {
|
|
EmergencyNumber emergencyNumber = new EmergencyNumber(enHal.number,
|
|
MccTable.countryCodeForMcc(enHal.mcc), enHal.mnc, enHal.categories,
|
|
RILUtils.primitiveArrayToArrayList(enHal.urns), enHal.sources,
|
|
EmergencyNumber.EMERGENCY_CALL_ROUTING_UNKNOWN);
|
|
response.add(emergencyNumber);
|
|
}
|
|
|
|
if (mRil.isLogOrTrace()) mRil.unsljLogRet(RIL_UNSOL_EMERGENCY_NUMBER_LIST, response);
|
|
|
|
// Cache emergency number list from last indication.
|
|
mRil.cacheEmergencyNumberListIndication(response);
|
|
|
|
// Notify emergency number list from radio to registrants
|
|
mRil.mEmergencyNumberListRegistrants.notifyRegistrants(
|
|
new AsyncResult(null, response, null));
|
|
}
|
|
|
|
/**
|
|
* Indicates that the radio system selection module has autonomously entered emergency
|
|
* callback mode.
|
|
* @param indicationType Type of radio indication
|
|
*/
|
|
public void enterEmergencyCallbackMode(int indicationType) {
|
|
mRil.processIndication(HAL_SERVICE_VOICE, indicationType);
|
|
|
|
if (mRil.isLogOrTrace()) mRil.unsljLog(RIL_UNSOL_ENTER_EMERGENCY_CALLBACK_MODE);
|
|
|
|
if (mRil.mEmergencyCallbackModeRegistrant != null) {
|
|
mRil.mEmergencyCallbackModeRegistrant.notifyRegistrant();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Indicates when Emergency Callback Mode ends. Indicates that the radio system selection module
|
|
* has proactively exited emergency callback mode.
|
|
* @param indicationType Type of radio indication
|
|
*/
|
|
public void exitEmergencyCallbackMode(int indicationType) {
|
|
mRil.processIndication(HAL_SERVICE_VOICE, indicationType);
|
|
|
|
if (mRil.isLogOrTrace()) mRil.unsljLog(RIL_UNSOL_EXIT_EMERGENCY_CALLBACK_MODE);
|
|
|
|
mRil.mExitEmergencyCallbackModeRegistrants.notifyRegistrants();
|
|
}
|
|
|
|
/**
|
|
* Indicates that network doesn't have in-band information, need to play out-band tone.
|
|
* @param indicationType Type of radio indication
|
|
* @param start true = start play ringback tone, false = stop playing ringback tone
|
|
*/
|
|
public void indicateRingbackTone(int indicationType, boolean start) {
|
|
mRil.processIndication(HAL_SERVICE_VOICE, indicationType);
|
|
|
|
if (mRil.isLogOrTrace()) mRil.unsljLogvRet(RIL_UNSOL_RINGBACK_TONE, start);
|
|
|
|
mRil.mRingbackToneRegistrants.notifyRegistrants(new AsyncResult(null, start, null));
|
|
}
|
|
|
|
/**
|
|
* Indicates when Supplementary service(SS) response is received when DIAL/USSD/SS is changed to
|
|
* SS by call control.
|
|
* @param indicationType Type of radio indication
|
|
* @param ss StkCcUnsolSsResult
|
|
*/
|
|
public void onSupplementaryServiceIndication(int indicationType,
|
|
android.hardware.radio.voice.StkCcUnsolSsResult ss) {
|
|
mRil.processIndication(HAL_SERVICE_VOICE, indicationType);
|
|
|
|
int num;
|
|
SsData ssData = new SsData();
|
|
|
|
ssData.serviceType = ssData.ServiceTypeFromRILInt(ss.serviceType);
|
|
ssData.requestType = ssData.RequestTypeFromRILInt(ss.requestType);
|
|
ssData.teleserviceType = ssData.TeleserviceTypeFromRILInt(ss.teleserviceType);
|
|
ssData.serviceClass = ss.serviceClass; // This is service class sent in the SS request.
|
|
ssData.result = ss.result; // This is the result of the SS request.
|
|
|
|
if (ssData.serviceType.isTypeCF() && ssData.requestType.isTypeInterrogation()) {
|
|
android.hardware.radio.voice.CfData cfData = ss.cfData[0];
|
|
num = cfData.cfInfo.length;
|
|
ssData.cfInfo = new CallForwardInfo[num];
|
|
|
|
for (int i = 0; i < num; i++) {
|
|
android.hardware.radio.voice.CallForwardInfo cfInfo = cfData.cfInfo[i];
|
|
ssData.cfInfo[i] = new CallForwardInfo();
|
|
ssData.cfInfo[i].status = cfInfo.status;
|
|
ssData.cfInfo[i].reason = cfInfo.reason;
|
|
ssData.cfInfo[i].serviceClass = cfInfo.serviceClass;
|
|
ssData.cfInfo[i].toa = cfInfo.toa;
|
|
ssData.cfInfo[i].number = cfInfo.number;
|
|
ssData.cfInfo[i].timeSeconds = cfInfo.timeSeconds;
|
|
mRil.riljLog("[SS Data] CF Info " + i + " : " + ssData.cfInfo[i]);
|
|
}
|
|
} else {
|
|
android.hardware.radio.voice.SsInfoData ssInfo = ss.ssInfo[0];
|
|
num = ssInfo.ssInfo.length;
|
|
ssData.ssInfo = new int[num];
|
|
for (int i = 0; i < num; i++) {
|
|
ssData.ssInfo[i] = ssInfo.ssInfo[i];
|
|
mRil.riljLog("[SS Data] SS Info " + i + " : " + ssData.ssInfo[i]);
|
|
}
|
|
}
|
|
|
|
if (mRil.isLogOrTrace()) mRil.unsljLogRet(RIL_UNSOL_ON_SS, ssData);
|
|
|
|
if (mRil.mSsRegistrant != null) {
|
|
mRil.mSsRegistrant.notifyRegistrant(new AsyncResult(null, ssData, null));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Indicates when a new USSD message is received. The USSD session is assumed to persist if the
|
|
* type code is REQUEST, otherwise the current session (if any) is assumed to have terminated.
|
|
* @param indicationType Type of radio indication
|
|
* @param ussdModeType USSD type code
|
|
* @param msg Message string in UTF-8, if applicable
|
|
*/
|
|
public void onUssd(int indicationType, int ussdModeType, String msg) {
|
|
mRil.processIndication(HAL_SERVICE_VOICE, indicationType);
|
|
|
|
if (mRil.isLogOrTrace()) mRil.unsljLogMore(RIL_UNSOL_ON_USSD, "" + ussdModeType);
|
|
|
|
// TODO: Clean this up with a parcelable class for better self-documentation
|
|
String[] resp = new String[]{"" + ussdModeType, msg};
|
|
if (mRil.mUSSDRegistrant != null) {
|
|
mRil.mUSSDRegistrant.notifyRegistrant(new AsyncResult(null, resp, null));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Indicates that framework/application must reset the uplink mute state.
|
|
* @param indicationType Type of radio indication
|
|
*/
|
|
public void resendIncallMute(int indicationType) {
|
|
mRil.processIndication(HAL_SERVICE_VOICE, indicationType);
|
|
|
|
if (mRil.isLogOrTrace()) mRil.unsljLog(RIL_UNSOL_RESEND_INCALL_MUTE);
|
|
|
|
mRil.mResendIncallMuteRegistrants.notifyRegistrants();
|
|
}
|
|
|
|
/**
|
|
* Indicates when Single Radio Voice Call Continuity (SRVCC) progress state has changed.
|
|
* @param indicationType Type of radio indication
|
|
* @param state New SRVCC State
|
|
*/
|
|
public void srvccStateNotify(int indicationType, int state) {
|
|
mRil.processIndication(HAL_SERVICE_VOICE, indicationType);
|
|
|
|
int[] response = new int[] {state};
|
|
|
|
if (mRil.isLogOrTrace()) mRil.unsljLogRet(RIL_UNSOL_SRVCC_STATE_NOTIFY, response);
|
|
|
|
mRil.writeMetricsSrvcc(state);
|
|
mRil.mSrvccStateRegistrants.notifyRegistrants(new AsyncResult(null, response, null));
|
|
}
|
|
|
|
/**
|
|
* Indicates when there is an ALPHA from UICC during Call Control.
|
|
* @param indicationType Type of radio indication
|
|
* @param alpha ALPHA string from UICC in UTF-8 format
|
|
*/
|
|
public void stkCallControlAlphaNotify(int indicationType, String alpha) {
|
|
mRil.processIndication(HAL_SERVICE_VOICE, indicationType);
|
|
|
|
if (mRil.isLogOrTrace()) mRil.unsljLogRet(RIL_UNSOL_STK_CC_ALPHA_NOTIFY, alpha);
|
|
|
|
if (mRil.mCatCcAlphaRegistrant != null) {
|
|
mRil.mCatCcAlphaRegistrant.notifyRegistrant(new AsyncResult(null, alpha, null));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Indicates when SIM wants application to setup a voice call.
|
|
* @param indicationType Type of radio indication
|
|
* @param timeout Timeout value in milliseconds for setting up voice call
|
|
*/
|
|
public void stkCallSetup(int indicationType, long timeout) {
|
|
mRil.processIndication(HAL_SERVICE_VOICE, indicationType);
|
|
|
|
if (mRil.isLogOrTrace()) mRil.unsljLogRet(RIL_UNSOL_STK_CALL_SETUP, timeout);
|
|
|
|
if (mRil.mCatCallSetUpRegistrant != null) {
|
|
mRil.mCatCallSetUpRegistrant.notifyRegistrant(new AsyncResult(null, timeout, null));
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public String getInterfaceHash() {
|
|
return IRadioVoiceIndication.HASH;
|
|
}
|
|
|
|
@Override
|
|
public int getInterfaceVersion() {
|
|
return IRadioVoiceIndication.VERSION;
|
|
}
|
|
}
|