| Methods Summary |
|---|
| public static int | convertCallState(PhoneConstants.State state)Convert the {@link PhoneConstants.State} enum into the TelephonyManager.CALL_STATE_*
constants for the public API.
switch (state) {
case RINGING:
return TelephonyManager.CALL_STATE_RINGING;
case OFFHOOK:
return TelephonyManager.CALL_STATE_OFFHOOK;
default:
return TelephonyManager.CALL_STATE_IDLE;
}
|
| public static PhoneConstants.State | convertCallState(int state)Convert the TelephonyManager.CALL_STATE_* constants into the
{@link PhoneConstants.State} enum for the public API.
switch (state) {
case TelephonyManager.CALL_STATE_RINGING:
return PhoneConstants.State.RINGING;
case TelephonyManager.CALL_STATE_OFFHOOK:
return PhoneConstants.State.OFFHOOK;
default:
return PhoneConstants.State.IDLE;
}
|
| public static int | convertDataActivityState(Phone.DataActivityState state)Convert the {@link Phone.DataActivityState} enum into the TelephonyManager.DATA_* constants
for the public API.
switch (state) {
case DATAIN:
return TelephonyManager.DATA_ACTIVITY_IN;
case DATAOUT:
return TelephonyManager.DATA_ACTIVITY_OUT;
case DATAINANDOUT:
return TelephonyManager.DATA_ACTIVITY_INOUT;
case DORMANT:
return TelephonyManager.DATA_ACTIVITY_DORMANT;
default:
return TelephonyManager.DATA_ACTIVITY_NONE;
}
|
| public static Phone.DataActivityState | convertDataActivityState(int state)Convert the TelephonyManager.DATA_* constants into the {@link Phone.DataActivityState} enum
for the public API.
switch (state) {
case TelephonyManager.DATA_ACTIVITY_IN:
return Phone.DataActivityState.DATAIN;
case TelephonyManager.DATA_ACTIVITY_OUT:
return Phone.DataActivityState.DATAOUT;
case TelephonyManager.DATA_ACTIVITY_INOUT:
return Phone.DataActivityState.DATAINANDOUT;
case TelephonyManager.DATA_ACTIVITY_DORMANT:
return Phone.DataActivityState.DORMANT;
default:
return Phone.DataActivityState.NONE;
}
|
| public static int | convertDataState(PhoneConstants.DataState state)Convert the {@link PhoneConstants.DataState} enum into the TelephonyManager.DATA_* constants
for the public API.
switch (state) {
case CONNECTING:
return TelephonyManager.DATA_CONNECTING;
case CONNECTED:
return TelephonyManager.DATA_CONNECTED;
case SUSPENDED:
return TelephonyManager.DATA_SUSPENDED;
default:
return TelephonyManager.DATA_DISCONNECTED;
}
|
| public static PhoneConstants.DataState | convertDataState(int state)Convert the TelephonyManager.DATA_* constants into {@link PhoneConstants.DataState} enum
for the public API.
switch (state) {
case TelephonyManager.DATA_CONNECTING:
return PhoneConstants.DataState.CONNECTING;
case TelephonyManager.DATA_CONNECTED:
return PhoneConstants.DataState.CONNECTED;
case TelephonyManager.DATA_SUSPENDED:
return PhoneConstants.DataState.SUSPENDED;
default:
return PhoneConstants.DataState.DISCONNECTED;
}
|
| public static int | convertPreciseCallState(Call.State state)Convert the {@link State} enum into the PreciseCallState.PRECISE_CALL_STATE_* constants
for the public API.
switch (state) {
case ACTIVE:
return PreciseCallState.PRECISE_CALL_STATE_ACTIVE;
case HOLDING:
return PreciseCallState.PRECISE_CALL_STATE_HOLDING;
case DIALING:
return PreciseCallState.PRECISE_CALL_STATE_DIALING;
case ALERTING:
return PreciseCallState.PRECISE_CALL_STATE_ALERTING;
case INCOMING:
return PreciseCallState.PRECISE_CALL_STATE_INCOMING;
case WAITING:
return PreciseCallState.PRECISE_CALL_STATE_WAITING;
case DISCONNECTED:
return PreciseCallState.PRECISE_CALL_STATE_DISCONNECTED;
case DISCONNECTING:
return PreciseCallState.PRECISE_CALL_STATE_DISCONNECTING;
default:
return PreciseCallState.PRECISE_CALL_STATE_IDLE;
}
|
| public static Call.State | convertPreciseCallState(int state)Convert the Call.State.* constants into the {@link State} enum
for the public API.
switch (state) {
case PreciseCallState.PRECISE_CALL_STATE_ACTIVE:
return Call.State.ACTIVE;
case PreciseCallState.PRECISE_CALL_STATE_HOLDING:
return Call.State.HOLDING;
case PreciseCallState.PRECISE_CALL_STATE_DIALING:
return Call.State.DIALING;
case PreciseCallState.PRECISE_CALL_STATE_ALERTING:
return Call.State.ALERTING;
case PreciseCallState.PRECISE_CALL_STATE_INCOMING:
return Call.State.INCOMING;
case PreciseCallState.PRECISE_CALL_STATE_WAITING:
return Call.State.WAITING;
case PreciseCallState.PRECISE_CALL_STATE_DISCONNECTED:
return Call.State.DISCONNECTED;
case PreciseCallState.PRECISE_CALL_STATE_DISCONNECTING:
return Call.State.DISCONNECTING;
default:
return Call.State.IDLE;
}
|
| private void | doNotifyDataConnection(com.android.internal.telephony.Phone sender, java.lang.String reason, java.lang.String apnType, PhoneConstants.DataState state)
int subId = sender.getSubId();
long dds = SubscriptionManager.getDefaultDataSubId();
if (DBG) log("subId = " + subId + ", DDS = " + dds);
// TODO
// use apnType as the key to which connection we're talking about.
// pass apnType back up to fetch particular for this one.
TelephonyManager telephony = TelephonyManager.getDefault();
LinkProperties linkProperties = null;
NetworkCapabilities networkCapabilities = null;
boolean roaming = false;
if (state == PhoneConstants.DataState.CONNECTED) {
linkProperties = sender.getLinkProperties(apnType);
networkCapabilities = sender.getNetworkCapabilities(apnType);
}
ServiceState ss = sender.getServiceState();
if (ss != null) roaming = ss.getDataRoaming();
try {
if (mRegistry != null) {
mRegistry.notifyDataConnectionForSubscriber(subId,
convertDataState(state),
sender.isDataConnectivityPossible(apnType), reason,
sender.getActiveApnHost(apnType),
apnType,
linkProperties,
networkCapabilities,
((telephony!=null) ? telephony.getDataNetworkType(subId) :
TelephonyManager.NETWORK_TYPE_UNKNOWN),
roaming);
}
} catch (RemoteException ex) {
// system process is dead
}
|
| private void | log(java.lang.String s)
Rlog.d(LOG_TAG, s);
|
| public void | notifyCallForwardingChanged(com.android.internal.telephony.Phone sender)
int subId = sender.getSubId();
try {
if (mRegistry != null) {
mRegistry.notifyCallForwardingChangedForSubscriber(subId,
sender.getCallForwardingIndicator());
}
} catch (RemoteException ex) {
// system process is dead
}
|
| public void | notifyCellInfo(com.android.internal.telephony.Phone sender, java.util.List cellInfo)
int subId = sender.getSubId();
try {
if (mRegistry != null) {
mRegistry.notifyCellInfoForSubscriber(subId, cellInfo);
}
} catch (RemoteException ex) {
}
|
| public void | notifyCellLocation(com.android.internal.telephony.Phone sender)
int subId = sender.getSubId();
Bundle data = new Bundle();
sender.getCellLocation().fillInNotifierBundle(data);
try {
if (mRegistry != null) {
mRegistry.notifyCellLocationForSubscriber(subId, data);
}
} catch (RemoteException ex) {
// system process is dead
}
|
| public void | notifyDataActivity(com.android.internal.telephony.Phone sender)
int subId = sender.getSubId();
try {
if (mRegistry != null) {
mRegistry.notifyDataActivityForSubscriber(subId,
convertDataActivityState(sender.getDataActivityState()));
}
} catch (RemoteException ex) {
// system process is dead
}
|
| public void | notifyDataConnection(com.android.internal.telephony.Phone sender, java.lang.String reason, java.lang.String apnType, PhoneConstants.DataState state)
doNotifyDataConnection(sender, reason, apnType, state);
|
| public void | notifyDataConnectionFailed(com.android.internal.telephony.Phone sender, java.lang.String reason, java.lang.String apnType)
int subId = sender.getSubId();
try {
if (mRegistry != null) {
mRegistry.notifyDataConnectionFailedForSubscriber(subId, reason, apnType);
}
} catch (RemoteException ex) {
// system process is dead
}
|
| public void | notifyDataConnectionRealTimeInfo(com.android.internal.telephony.Phone sender, android.telephony.DataConnectionRealTimeInfo dcRtInfo)
try {
mRegistry.notifyDataConnectionRealTimeInfo(dcRtInfo);
} catch (RemoteException ex) {
}
|
| public void | notifyDisconnectCause(int cause, int preciseCause)
// FIXME: subId?
try {
mRegistry.notifyDisconnectCause(cause, preciseCause);
} catch (RemoteException ex) {
// system process is dead
}
|
| public void | notifyMessageWaitingChanged(com.android.internal.telephony.Phone sender)
int phoneId = sender.getPhoneId();
int subId = sender.getSubId();
try {
if (mRegistry != null) {
mRegistry.notifyMessageWaitingChangedForPhoneId(phoneId, subId,
sender.getMessageWaitingIndicator());
}
} catch (RemoteException ex) {
// system process is dead
}
|
| public void | notifyOemHookRawEventForSubscriber(int subId, byte[] rawData)
try {
mRegistry.notifyOemHookRawEventForSubscriber(subId, rawData);
} catch (RemoteException ex) {
// system process is dead
}
|
| public void | notifyOtaspChanged(com.android.internal.telephony.Phone sender, int otaspMode)
// FIXME: subId?
try {
if (mRegistry != null) {
mRegistry.notifyOtaspChanged(otaspMode);
}
} catch (RemoteException ex) {
// system process is dead
}
|
| public void | notifyPhoneState(com.android.internal.telephony.Phone sender)
Call ringingCall = sender.getRingingCall();
int subId = sender.getSubId();
String incomingNumber = "";
if (ringingCall != null && ringingCall.getEarliestConnection() != null){
incomingNumber = ringingCall.getEarliestConnection().getAddress();
}
try {
if (mRegistry != null) {
mRegistry.notifyCallStateForSubscriber(subId,
convertCallState(sender.getState()), incomingNumber);
}
} catch (RemoteException ex) {
// system process is dead
}
|
| public void | notifyPreciseCallState(com.android.internal.telephony.Phone sender)
// FIXME: subId?
Call ringingCall = sender.getRingingCall();
Call foregroundCall = sender.getForegroundCall();
Call backgroundCall = sender.getBackgroundCall();
if (ringingCall != null && foregroundCall != null && backgroundCall != null) {
try {
mRegistry.notifyPreciseCallState(
convertPreciseCallState(ringingCall.getState()),
convertPreciseCallState(foregroundCall.getState()),
convertPreciseCallState(backgroundCall.getState()));
} catch (RemoteException ex) {
// system process is dead
}
}
|
| public void | notifyPreciseDataConnectionFailed(com.android.internal.telephony.Phone sender, java.lang.String reason, java.lang.String apnType, java.lang.String apn, java.lang.String failCause)
// FIXME: subId?
try {
mRegistry.notifyPreciseDataConnectionFailed(reason, apnType, apn, failCause);
} catch (RemoteException ex) {
// system process is dead
}
|
| public void | notifyServiceState(com.android.internal.telephony.Phone sender)
ServiceState ss = sender.getServiceState();
int phoneId = sender.getPhoneId();
int subId = sender.getSubId();
Rlog.d(LOG_TAG, "nofityServiceState: mRegistry=" + mRegistry + " ss=" + ss
+ " sender=" + sender + " phondId=" + phoneId + " subId=" + subId);
if (ss == null) {
ss = new ServiceState();
ss.setStateOutOfService();
}
try {
if (mRegistry != null) {
mRegistry.notifyServiceStateForPhoneId(phoneId, subId, ss);
}
} catch (RemoteException ex) {
// system process is dead
}
|
| public void | notifySignalStrength(com.android.internal.telephony.Phone sender)
int subId = sender.getSubId();
Rlog.d(LOG_TAG, "notifySignalStrength: mRegistry=" + mRegistry
+ " ss=" + sender.getSignalStrength() + " sender=" + sender);
try {
if (mRegistry != null) {
mRegistry.notifySignalStrengthForSubscriber(subId, sender.getSignalStrength());
}
} catch (RemoteException ex) {
// system process is dead
}
|
| public void | notifyVoLteServiceStateChanged(com.android.internal.telephony.Phone sender, android.telephony.VoLteServiceState lteState)
// FIXME: subID
try {
mRegistry.notifyVoLteServiceStateChanged(lteState);
} catch (RemoteException ex) {
// system process is dead
}
|
