* {@link TelecomManager} uses registered {@link PhoneAccount}s to present the user with * alternative options when placing a phone call. When building a {@link PhoneAccount}, the app * should supply a valid {@link PhoneAccountHandle} that references the connection service * implementation Telecom will use to interact with the app. */ public final class PhoneAccount implements Parcelable { /** * Integer extra which determines the order in which {@link PhoneAccount}s are sorted * * This is an extras key set via {@link Builder#setExtras} which determines the order in which * {@link PhoneAccount}s from the same {@link ConnectionService} are sorted. The accounts * are sorted in ascending order by this key, and this ordering is used to * determine priority when a call can be placed via multiple accounts. * * When multiple {@link PhoneAccount}s are supplied with the same sort order key, no ordering is * guaranteed between those {@link PhoneAccount}s. Additionally, no ordering is guaranteed * between {@link PhoneAccount}s that do not supply this extra, and all such accounts * will be sorted after the accounts that do supply this extra. * * An example of a sort order key is slot index (see {@link TelephonyManager#getSlotIndex()}), * which is the one used by the cell Telephony stack. * @hide */ @SystemApi public static final String EXTRA_SORT_ORDER = "android.telecom.extra.SORT_ORDER"; /** * {@link PhoneAccount} extras key (see {@link PhoneAccount#getExtras()}) which determines the * maximum permitted length of a call subject specified via the * {@link TelecomManager#EXTRA_CALL_SUBJECT} extra on an * {@link android.content.Intent#ACTION_CALL} intent. Ultimately a {@link ConnectionService} is * responsible for enforcing the maximum call subject length when sending the message, however * this extra is provided so that the user interface can proactively limit the length of the * call subject as the user types it. */ public static final String EXTRA_CALL_SUBJECT_MAX_LENGTH = "android.telecom.extra.CALL_SUBJECT_MAX_LENGTH"; /** * {@link PhoneAccount} extras key (see {@link PhoneAccount#getExtras()}) which determines the * character encoding to be used when determining the length of messages. * The user interface can use this when determining the number of characters the user may type * in a call subject. If empty-string, the call subject message size limit will be enforced on * a 1:1 basis. That is, each character will count towards the messages size limit as a single * character. If a character encoding is specified, the message size limit will be based on the * number of bytes in the message per the specified encoding. See * {@link #EXTRA_CALL_SUBJECT_MAX_LENGTH} for more information on the call subject maximum * length. */ public static final String EXTRA_CALL_SUBJECT_CHARACTER_ENCODING = "android.telecom.extra.CALL_SUBJECT_CHARACTER_ENCODING"; /** * Boolean {@link PhoneAccount} extras key (see {@link PhoneAccount#getExtras()}) which * indicates that all calls from this {@link PhoneAccount} should be treated as VoIP calls * rather than cellular calls by the Telecom audio handling logic. */ public static final String EXTRA_ALWAYS_USE_VOIP_AUDIO_MODE = "android.telecom.extra.ALWAYS_USE_VOIP_AUDIO_MODE"; /** * Boolean {@link PhoneAccount} extras key (see {@link PhoneAccount#getExtras()}) which * indicates whether this {@link PhoneAccount} is capable of supporting a request to handover a * connection (see {@code android.telecom.Call#handoverTo()}) to this {@link PhoneAccount} from * a {@link PhoneAccount} specifying {@link #EXTRA_SUPPORTS_HANDOVER_FROM}. *
* A handover request is initiated by the user from the default dialer app to indicate a desire * to handover a call from one {@link PhoneAccount}/{@link ConnectionService} to another. */ public static final String EXTRA_SUPPORTS_HANDOVER_TO = "android.telecom.extra.SUPPORTS_HANDOVER_TO"; /** * Boolean {@link PhoneAccount} extras key (see {@link PhoneAccount#getExtras()}) which * indicates whether this {@link PhoneAccount} supports using a fallback if video calling is * not available. This extra is for device level support, {@link * android.telephony.CarrierConfigManager#KEY_ALLOW_VIDEO_CALLING_FALLBACK_BOOL} should also * be checked to ensure it is not disabled by individual carrier. * * @hide */ public static final String EXTRA_SUPPORTS_VIDEO_CALLING_FALLBACK = "android.telecom.extra.SUPPORTS_VIDEO_CALLING_FALLBACK"; /** * Boolean {@link PhoneAccount} extras key (see {@link PhoneAccount#getExtras()}) which * indicates whether this {@link PhoneAccount} is capable of supporting a request to handover a * connection from this {@link PhoneAccount} to another {@link PhoneAccount}. * (see {@code android.telecom.Call#handoverTo()}) which specifies * {@link #EXTRA_SUPPORTS_HANDOVER_TO}. *
* A handover request is initiated by the user from the default dialer app to indicate a desire * to handover a call from one {@link PhoneAccount}/{@link ConnectionService} to another. */ public static final String EXTRA_SUPPORTS_HANDOVER_FROM = "android.telecom.extra.SUPPORTS_HANDOVER_FROM"; /** * Boolean {@link PhoneAccount} extras key (see {@link PhoneAccount#getExtras()}) which * indicates whether a Self-Managed {@link PhoneAccount} should log its calls to the call log. * Self-Managed {@link PhoneAccount}s are responsible for their own notifications, so the system * will not create a notification when a missed call is logged. *
* By default, Self-Managed {@link PhoneAccount}s do not log their calls to the call log. * Setting this extra to {@code true} provides a means for them to log their calls. *
* Note: Only calls where the {@link Call.Details#getHandle()} {@link Uri#getScheme()} is * {@link #SCHEME_SIP} or {@link #SCHEME_TEL} will be logged at the current time. */ public static final String EXTRA_LOG_SELF_MANAGED_CALLS = "android.telecom.extra.LOG_SELF_MANAGED_CALLS"; /** * Boolean {@link PhoneAccount} extras key (see {@link PhoneAccount#getExtras()}) which * indicates whether calls for a {@link PhoneAccount} should generate a "call recording tone" * when the user is recording audio on the device. *
* The call recording tone is played over the telephony audio stream so that the remote party * has an audible indication that it is possible their call is being recorded using a call * recording app on the device. *
* This extra only has an effect for calls placed via Telephony (e.g. * {@link #CAPABILITY_SIM_SUBSCRIPTION}). *
* The call recording tone is a 1400 hz tone which repeats every 15 seconds while recording is * in progress. * @hide */ @SystemApi public static final String EXTRA_PLAY_CALL_RECORDING_TONE = "android.telecom.extra.PLAY_CALL_RECORDING_TONE"; /** * Boolean {@link PhoneAccount} extras key (see {@link PhoneAccount#getExtras()} which * indicates whether calls for a {@link PhoneAccount} should skip call filtering. *
* If not specified, this will default to false; all calls will undergo call filtering unless * specifically exempted (e.g. {@link Connection#PROPERTY_EMERGENCY_CALLBACK_MODE}.) However, * this may be used to skip call filtering when it has already been performed on another device. * @hide */ public static final String EXTRA_SKIP_CALL_FILTERING = "android.telecom.extra.SKIP_CALL_FILTERING"; /** * Boolean {@link PhoneAccount} extras key (see {@link PhoneAccount#getExtras()}) which * indicates whether a Self-managed {@link PhoneAccount} want to expose its calls to all * {@link InCallService} which declares the metadata * {@link TelecomManager#METADATA_INCLUDE_SELF_MANAGED_CALLS}. */ public static final String EXTRA_ADD_SELF_MANAGED_CALLS_TO_INCALLSERVICE = "android.telecom.extra.ADD_SELF_MANAGED_CALLS_TO_INCALLSERVICE"; /** * Flag indicating that this {@code PhoneAccount} can act as a connection manager for * other connections. The {@link ConnectionService} associated with this {@code PhoneAccount} * will be allowed to manage phone calls including using its own proprietary phone-call * implementation (like VoIP calling) to make calls instead of the telephony stack. *
* When a user opts to place a call using the SIM-based telephony stack, the * {@link ConnectionService} associated with this {@code PhoneAccount} will be attempted first * if the user has explicitly selected it to be used as the default connection manager. *
* See {@link #getCapabilities} */ public static final int CAPABILITY_CONNECTION_MANAGER = 0x1; /** * Flag indicating that this {@code PhoneAccount} can make phone calls in place of * traditional SIM-based telephony calls. This account will be treated as a distinct method * for placing calls alongside the traditional SIM-based telephony stack. This flag is * distinct from {@link #CAPABILITY_CONNECTION_MANAGER} in that it is not allowed to manage * or place calls from the built-in telephony stack. *
* See {@link #getCapabilities} *
*/ public static final int CAPABILITY_CALL_PROVIDER = 0x2; /** * Flag indicating that this {@code PhoneAccount} represents a built-in PSTN SIM * subscription. *
* Only the Android framework can register a {@code PhoneAccount} having this capability. *
* See {@link #getCapabilities} */ public static final int CAPABILITY_SIM_SUBSCRIPTION = 0x4; /** * Flag indicating that this {@code PhoneAccount} is currently able to place video calls. *
* See also {@link #CAPABILITY_SUPPORTS_VIDEO_CALLING} which indicates whether the * {@code PhoneAccount} supports placing video calls. *
* See {@link #getCapabilities} */ public static final int CAPABILITY_VIDEO_CALLING = 0x8; /** * Flag indicating that this {@code PhoneAccount} is capable of placing emergency calls. * By default all PSTN {@code PhoneAccount}s are capable of placing emergency calls. *
* See {@link #getCapabilities} */ public static final int CAPABILITY_PLACE_EMERGENCY_CALLS = 0x10; /** * Flag indicating that this {@code PhoneAccount} is capable of being used by all users. This * should only be used by system apps (and will be ignored for all other apps trying to use it). *
* See {@link #getCapabilities} * @hide */ @SystemApi public static final int CAPABILITY_MULTI_USER = 0x20; /** * Flag indicating that this {@code PhoneAccount} supports a subject for Calls. This means a * caller is able to specify a short subject line for an outgoing call. A capable receiving * device displays the call subject on the incoming call screen. *
* See {@link #getCapabilities} */ public static final int CAPABILITY_CALL_SUBJECT = 0x40; /** * Flag indicating that this {@code PhoneAccount} should only be used for emergency calls. *
* See {@link #getCapabilities} * @hide */ @SystemApi public static final int CAPABILITY_EMERGENCY_CALLS_ONLY = 0x80; /** * Flag indicating that for this {@code PhoneAccount}, the ability to make a video call to a * number relies on presence. Should only be set if the {@code PhoneAccount} also has * {@link #CAPABILITY_VIDEO_CALLING}. *
* Note: As of Android 12, using the * {@link android.provider.ContactsContract.Data#CARRIER_PRESENCE_VT_CAPABLE} bit on the * {@link android.provider.ContactsContract.Data#CARRIER_PRESENCE} column to indicate whether * a contact's phone number supports video calling has been deprecated and should only be used * on devices where {@link CarrierConfigManager#KEY_USE_RCS_PRESENCE_BOOL} is set. On newer * devices, applications must use {@link android.telephony.ims.RcsUceAdapter} instead to * determine whether or not a contact's phone number supports carrier video calling. *
* See {@link #getCapabilities} */ public static final int CAPABILITY_VIDEO_CALLING_RELIES_ON_PRESENCE = 0x100; /** * Flag indicating that for this {@link PhoneAccount}, emergency video calling is allowed. *
* When set, Telecom will allow emergency video calls to be placed. When not set, Telecom will * convert all outgoing video calls to emergency numbers to audio-only. * @hide */ @SystemApi public static final int CAPABILITY_EMERGENCY_VIDEO_CALLING = 0x200; /** * Flag indicating that this {@link PhoneAccount} supports video calling. * This is not an indication that the {@link PhoneAccount} is currently able to make a video * call, but rather that it has the ability to make video calls (but not necessarily at this * time). *
* Whether a {@link PhoneAccount} can make a video call is ultimately controlled by * {@link #CAPABILITY_VIDEO_CALLING}, which indicates whether the {@link PhoneAccount} is * currently capable of making a video call. Consider a case where, for example, a * {@link PhoneAccount} supports making video calls (e.g. * {@link #CAPABILITY_SUPPORTS_VIDEO_CALLING}), but a current lack of network connectivity * prevents video calls from being made (e.g. {@link #CAPABILITY_VIDEO_CALLING}). *
* See {@link #getCapabilities} */ public static final int CAPABILITY_SUPPORTS_VIDEO_CALLING = 0x400; /** * Flag indicating that this {@link PhoneAccount} is responsible for managing its own * {@link Connection}s. This type of {@link PhoneAccount} is ideal for use with standalone * calling apps which do not wish to use the default phone app for {@link Connection} UX, * but which want to leverage the call and audio routing capabilities of the Telecom framework. *
* When set, {@link Connection}s created by the self-managed {@link ConnectionService} will not * be surfaced to implementations of the {@link InCallService} API. Thus it is the * responsibility of a self-managed {@link ConnectionService} to provide a user interface for * its {@link Connection}s. *
* Self-managed {@link Connection}s will, however, be displayed on connected Bluetooth devices. */ public static final int CAPABILITY_SELF_MANAGED = 0x800; /** * Flag indicating that this {@link PhoneAccount} is capable of making a call with an * RTT (Real-time text) session. * When set, Telecom will attempt to open an RTT session on outgoing calls that specify * that they should be placed with an RTT session , and the in-call app will be displayed * with text entry fields for RTT. Likewise, the in-call app can request that an RTT * session be opened during a call if this bit is set. */ public static final int CAPABILITY_RTT = 0x1000; /** * Flag indicating that this {@link PhoneAccount} is the preferred SIM subscription for * emergency calls. A {@link PhoneAccount} that sets this capability must also * set the {@link #CAPABILITY_SIM_SUBSCRIPTION} and {@link #CAPABILITY_PLACE_EMERGENCY_CALLS} * capabilities. There must only be one emergency preferred {@link PhoneAccount} on the device. *
* When set, Telecom will prefer this {@link PhoneAccount} over others for emergency calling,
* even if the emergency call was placed with a specific {@link PhoneAccount} set using the
* extra{@link TelecomManager#EXTRA_PHONE_ACCOUNT_HANDLE} in
* {@link Intent#ACTION_CALL_EMERGENCY} or {@link TelecomManager#placeCall(Uri, Bundle)}.
*
* @hide
*/
@SystemApi
public static final int CAPABILITY_EMERGENCY_PREFERRED = 0x2000;
/**
* An adhoc conference call is established by providing a list of addresses to
* {@code TelecomManager#startConference(List
* {@code PhoneAccount}s only support extra values of type: {@link String}, {@link Integer},
* and {@link Boolean}. Extras which are not of these types are ignored.
*
* @param extras
* @return
*/
public Builder setExtras(Bundle extras) {
mExtras = extras;
return this;
}
/**
* Sets the enabled state of the phone account.
*
* @param isEnabled The enabled state.
* @return The builder.
* @hide
*/
public Builder setIsEnabled(boolean isEnabled) {
mIsEnabled = isEnabled;
return this;
}
/**
* Sets the group Id of the {@link PhoneAccount}. When a new {@link PhoneAccount} is
* registered to Telecom, it will replace another {@link PhoneAccount} that is already
* registered in Telecom and take on the current user defaults and enabled status. There can
* only be one {@link PhoneAccount} with a non-empty group number registered to Telecom at a
* time. By default, there is no group Id for a {@link PhoneAccount} (an empty String). Only
* grouped {@link PhoneAccount}s with the same {@link ConnectionService} can be replaced.
*
* Note: This is an API specific to the Telephony stack; the group Id will be ignored for
* callers not holding the correct permission.
*
* @param groupId The group Id of the {@link PhoneAccount} that will replace any other
* registered {@link PhoneAccount} in Telecom with the same Group Id.
* @return The builder
* @hide
*/
@SystemApi
@RequiresPermission(MODIFY_PHONE_STATE)
public @NonNull Builder setGroupId(@NonNull String groupId) {
if (groupId != null) {
mGroupId = groupId;
} else {
mGroupId = "";
}
return this;
}
/**
* Sets the audio routes supported by this {@link PhoneAccount}.
*
* @param routes bit mask of available routes.
* @return The builder.
* @hide
*/
public Builder setSupportedAudioRoutes(int routes) {
mSupportedAudioRoutes = routes;
return this;
}
/**
* Creates an instance of a {@link PhoneAccount} based on the current builder settings.
*
* @return The {@link PhoneAccount}.
*/
public PhoneAccount build() {
// If no supported URI schemes were defined, assume "tel" is supported.
if (mSupportedUriSchemes.isEmpty()) {
addSupportedUriScheme(SCHEME_TEL);
}
return new PhoneAccount(
mAccountHandle,
mAddress,
mSubscriptionAddress,
mCapabilities,
mIcon,
mHighlightColor,
mLabel,
mShortDescription,
mSupportedUriSchemes,
mExtras,
mSupportedAudioRoutes,
mIsEnabled,
mGroupId);
}
}
private PhoneAccount(
PhoneAccountHandle account,
Uri address,
Uri subscriptionAddress,
int capabilities,
Icon icon,
int highlightColor,
CharSequence label,
CharSequence shortDescription,
List
*
* @return The subscription number, suitable for display to the user.
*/
public Uri getSubscriptionAddress() {
return mSubscriptionAddress;
}
/**
* The capabilities of this {@code PhoneAccount}.
*
* @return A bit field of flags describing this {@code PhoneAccount}'s capabilities.
*/
public int getCapabilities() {
return mCapabilities;
}
/**
* Determines if this {@code PhoneAccount} has a capabilities specified by the passed in
* bit mask.
*
* @param capability The capabilities to check.
* @return {@code true} if the phone account has the capability.
*/
public boolean hasCapabilities(int capability) {
return (mCapabilities & capability) == capability;
}
/**
* Determines if this {@code PhoneAccount} has routes specified by the passed in bit mask.
*
* @param route The routes to check.
* @return {@code true} if the phone account has the routes.
* @hide
*/
public boolean hasAudioRoutes(int routes) {
return (mSupportedAudioRoutes & routes) == routes;
}
/**
* A short label describing a {@code PhoneAccount}.
*
* @return A label for this {@code PhoneAccount}.
*/
public CharSequence getLabel() {
return mLabel;
}
/**
* A short paragraph describing this {@code PhoneAccount}.
*
* @return A description for this {@code PhoneAccount}.
*/
public CharSequence getShortDescription() {
return mShortDescription;
}
/**
* The URI schemes supported by this {@code PhoneAccount}.
*
* @return The URI schemes.
*/
public List
* A {@link ConnectionService} may provide implementation specific information about the
* {@link PhoneAccount} via the extras.
*
* @return The extras.
*/
public Bundle getExtras() {
return mExtras;
}
/**
* The audio routes supported by this {@code PhoneAccount}.
*
* @hide
*/
public int getSupportedAudioRoutes() {
return mSupportedAudioRoutes;
}
/**
* The icon to represent this {@code PhoneAccount}.
*
* @return The icon.
*/
public Icon getIcon() {
return mIcon;
}
/**
* Indicates whether the user has enabled this {@code PhoneAccount} or not. This value is only
* populated for {@code PhoneAccount}s returned by {@link TelecomManager#getPhoneAccount}.
*
* @return {@code true} if the account is enabled by the user, {@code false} otherwise.
*/
public boolean isEnabled() {
return mIsEnabled;
}
/**
* A non-empty {@link String} representing the group that A {@link PhoneAccount} is in or an
* empty {@link String} if the {@link PhoneAccount} is not in a group. If this
* {@link PhoneAccount} is in a group, this new {@link PhoneAccount} will replace a registered
* {@link PhoneAccount} that is in the same group. When the {@link PhoneAccount} is replaced,
* its user defined defaults and enabled status will also pass to this new {@link PhoneAccount}.
* Only {@link PhoneAccount}s that share the same {@link ConnectionService} can be replaced.
*
* @return A non-empty String Id if this {@link PhoneAccount} belongs to a group.
* @hide
*/
public String getGroupId() {
return mGroupId;
}
/**
* Determines if the {@link PhoneAccount} supports calls to/from addresses with a specified URI
* scheme.
*
* @param uriScheme The URI scheme to check.
* @return {@code true} if the {@code PhoneAccount} supports calls to/from addresses with the
* specified URI scheme.
*/
public boolean supportsUriScheme(String uriScheme) {
if (mSupportedUriSchemes == null || uriScheme == null) {
return false;
}
for (String scheme : mSupportedUriSchemes) {
if (scheme != null && scheme.equals(uriScheme)) {
return true;
}
}
return false;
}
/**
* A highlight color to use in displaying information about this {@code PhoneAccount}.
*
* @return A hexadecimal color value.
*/
public int getHighlightColor() {
return mHighlightColor;
}
/**
* Sets the enabled state of the phone account.
* @hide
*/
public void setIsEnabled(boolean isEnabled) {
mIsEnabled = isEnabled;
}
/**
* @return {@code true} if the {@link PhoneAccount} is self-managed, {@code false} otherwise.
* @hide
*/
public boolean isSelfManaged() {
return (mCapabilities & CAPABILITY_SELF_MANAGED) == CAPABILITY_SELF_MANAGED;
}
//
// Parcelable implementation
//
@Override
public int describeContents() {
return 0;
}
@Override
public void writeToParcel(Parcel out, int flags) {
if (mAccountHandle == null) {
out.writeInt(0);
} else {
out.writeInt(1);
mAccountHandle.writeToParcel(out, flags);
}
if (mAddress == null) {
out.writeInt(0);
} else {
out.writeInt(1);
mAddress.writeToParcel(out, flags);
}
if (mSubscriptionAddress == null) {
out.writeInt(0);
} else {
out.writeInt(1);
mSubscriptionAddress.writeToParcel(out, flags);
}
out.writeInt(mCapabilities);
out.writeInt(mHighlightColor);
out.writeCharSequence(mLabel);
out.writeCharSequence(mShortDescription);
out.writeStringList(mSupportedUriSchemes);
if (mIcon == null) {
out.writeInt(0);
} else {
out.writeInt(1);
mIcon.writeToParcel(out, flags);
}
out.writeByte((byte) (mIsEnabled ? 1 : 0));
out.writeBundle(mExtras);
out.writeString(mGroupId);
out.writeInt(mSupportedAudioRoutes);
}
public static final @android.annotation.NonNull Creator