2526568630
This CL creates two new PhoneAccount capabilities for the SIM call manager (and potentially telephony itself for PSTN PhoneAccounts) to advertise that they support voice calling, potentially independent of voice service state. With this information, telecom will feed updated back into telephony for plumbing through the standard ServiceState-based APIs. Bug: 205737545 Test: atest android.telecom.cts.PhoneAccountOperationsTest (an additional CTS test for the TelephonyManager API will be added as a follow-up) Change-Id: If7a5b03a7aa630823ac238ef27721e5e6cc596e6
1206 lines
46 KiB
Java
1206 lines
46 KiB
Java
/*
|
|
* Copyright (C) 2014 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 android.telecom;
|
|
|
|
import static android.Manifest.permission.MODIFY_PHONE_STATE;
|
|
|
|
import android.annotation.NonNull;
|
|
import android.annotation.RequiresPermission;
|
|
import android.annotation.SystemApi;
|
|
import android.content.Intent;
|
|
import android.graphics.drawable.Icon;
|
|
import android.net.Uri;
|
|
import android.os.Bundle;
|
|
import android.os.Parcel;
|
|
import android.os.Parcelable;
|
|
import android.telephony.CarrierConfigManager;
|
|
import android.telephony.TelephonyManager;
|
|
import android.text.TextUtils;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.Collections;
|
|
import java.util.List;
|
|
import java.util.Objects;
|
|
|
|
/**
|
|
* Represents a distinct method to place or receive a phone call. Apps which can place calls and
|
|
* want those calls to be integrated into the dialer and in-call UI should build an instance of
|
|
* this class and register it with the system using {@link TelecomManager}.
|
|
* <p>
|
|
* {@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}.
|
|
* <p>
|
|
* 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}.
|
|
* <p>
|
|
* 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.
|
|
* <p>
|
|
* 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.
|
|
* <p>
|
|
* 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.
|
|
* <p>
|
|
* 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.
|
|
* <p>
|
|
* This extra only has an effect for calls placed via Telephony (e.g.
|
|
* {@link #CAPABILITY_SIM_SUBSCRIPTION}).
|
|
* <p>
|
|
* 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.
|
|
* <p>
|
|
* 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.
|
|
* <p>
|
|
* 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.
|
|
* <p>
|
|
* 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.
|
|
* <p>
|
|
* See {@link #getCapabilities}
|
|
* <p>
|
|
*/
|
|
public static final int CAPABILITY_CALL_PROVIDER = 0x2;
|
|
|
|
/**
|
|
* Flag indicating that this {@code PhoneAccount} represents a built-in PSTN SIM
|
|
* subscription.
|
|
* <p>
|
|
* Only the Android framework can register a {@code PhoneAccount} having this capability.
|
|
* <p>
|
|
* See {@link #getCapabilities}
|
|
*/
|
|
public static final int CAPABILITY_SIM_SUBSCRIPTION = 0x4;
|
|
|
|
/**
|
|
* Flag indicating that this {@code PhoneAccount} is currently able to place video calls.
|
|
* <p>
|
|
* See also {@link #CAPABILITY_SUPPORTS_VIDEO_CALLING} which indicates whether the
|
|
* {@code PhoneAccount} supports placing video calls.
|
|
* <p>
|
|
* 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.
|
|
* <p>
|
|
* 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).
|
|
* <p>
|
|
* 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.
|
|
* <p>
|
|
* See {@link #getCapabilities}
|
|
*/
|
|
public static final int CAPABILITY_CALL_SUBJECT = 0x40;
|
|
|
|
/**
|
|
* Flag indicating that this {@code PhoneAccount} should only be used for emergency calls.
|
|
* <p>
|
|
* 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}.
|
|
* <p>
|
|
* 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.
|
|
* <p>
|
|
* 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.
|
|
* <p>
|
|
* 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).
|
|
* <p>
|
|
* 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}).
|
|
* <p>
|
|
* 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.
|
|
* <p>
|
|
* 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.
|
|
* <p>
|
|
* 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.
|
|
* <p>
|
|
* 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<Uri>, int videoState)} where the
|
|
* {@link ConnectionService} is responsible for connecting all indicated participants
|
|
* to a conference simultaneously.
|
|
* This is in contrast to conferences formed by merging calls together (e.g. using
|
|
* {@link android.telecom.Call#mergeConference()}).
|
|
*/
|
|
public static final int CAPABILITY_ADHOC_CONFERENCE_CALLING = 0x4000;
|
|
|
|
/**
|
|
* Flag indicating whether this {@link PhoneAccount} is capable of supporting the call composer
|
|
* functionality for enriched calls.
|
|
*/
|
|
public static final int CAPABILITY_CALL_COMPOSER = 0x8000;
|
|
|
|
/**
|
|
* Flag indicating that this {@link PhoneAccount} provides SIM-based voice calls, potentially as
|
|
* an over-the-top solution such as wi-fi calling.
|
|
*
|
|
* <p>Similar to {@link #CAPABILITY_SUPPORTS_VIDEO_CALLING}, this capability indicates this
|
|
* {@link PhoneAccount} has the ability to make voice calls (but not necessarily at this time).
|
|
* Whether this {@link PhoneAccount} can make a voice call is ultimately controlled by {@link
|
|
* #CAPABILITY_VOICE_CALLING_AVAILABLE}, which indicates whether this {@link PhoneAccount} is
|
|
* currently capable of making a voice call. Consider a case where, for example, a {@link
|
|
* PhoneAccount} supports making voice calls (e.g. {@link
|
|
* #CAPABILITY_SUPPORTS_VOICE_CALLING_INDICATIONS}), but a current lack of network connectivity
|
|
* prevents voice calls from being made (e.g. {@link #CAPABILITY_VOICE_CALLING_AVAILABLE}).
|
|
*
|
|
* <p>In order to declare this capability, this {@link PhoneAccount} must also declare {@link
|
|
* #CAPABILITY_SIM_SUBSCRIPTION} or {@link #CAPABILITY_CONNECTION_MANAGER} and satisfy the
|
|
* associated requirements.
|
|
*
|
|
* @see #CAPABILITY_VOICE_CALLING_AVAILABLE
|
|
* @see #getCapabilities
|
|
*/
|
|
public static final int CAPABILITY_SUPPORTS_VOICE_CALLING_INDICATIONS = 0x10000;
|
|
|
|
/**
|
|
* Flag indicating that this {@link PhoneAccount} is <em>currently</em> able to place SIM-based
|
|
* voice calls, similar to {@link #CAPABILITY_VIDEO_CALLING}.
|
|
*
|
|
* <p>See also {@link #CAPABILITY_SUPPORTS_VOICE_CALLING_INDICATIONS}, which indicates whether
|
|
* the {@code PhoneAccount} supports placing SIM-based voice calls or not.
|
|
*
|
|
* <p>In order to declare this capability, this {@link PhoneAccount} must also declare {@link
|
|
* #CAPABILITY_SIM_SUBSCRIPTION} or {@link #CAPABILITY_CONNECTION_MANAGER} and satisfy the
|
|
* associated requirements.
|
|
*
|
|
* @see #CAPABILITY_SUPPORTS_VOICE_CALLING_INDICATIONS
|
|
* @see #getCapabilities
|
|
*/
|
|
public static final int CAPABILITY_VOICE_CALLING_AVAILABLE = 0x20000;
|
|
|
|
/* NEXT CAPABILITY: 0x40000 */
|
|
|
|
/**
|
|
* URI scheme for telephone number URIs.
|
|
*/
|
|
public static final String SCHEME_TEL = "tel";
|
|
|
|
/**
|
|
* URI scheme for voicemail URIs.
|
|
*/
|
|
public static final String SCHEME_VOICEMAIL = "voicemail";
|
|
|
|
/**
|
|
* URI scheme for SIP URIs.
|
|
*/
|
|
public static final String SCHEME_SIP = "sip";
|
|
|
|
/**
|
|
* Indicating no icon tint is set.
|
|
* @hide
|
|
*/
|
|
public static final int NO_ICON_TINT = 0;
|
|
|
|
/**
|
|
* Indicating no hightlight color is set.
|
|
*/
|
|
public static final int NO_HIGHLIGHT_COLOR = 0;
|
|
|
|
/**
|
|
* Indicating no resource ID is set.
|
|
*/
|
|
public static final int NO_RESOURCE_ID = -1;
|
|
|
|
private final PhoneAccountHandle mAccountHandle;
|
|
private final Uri mAddress;
|
|
private final Uri mSubscriptionAddress;
|
|
private final int mCapabilities;
|
|
private final int mHighlightColor;
|
|
private final CharSequence mLabel;
|
|
private final CharSequence mShortDescription;
|
|
private final List<String> mSupportedUriSchemes;
|
|
private final int mSupportedAudioRoutes;
|
|
private final Icon mIcon;
|
|
private final Bundle mExtras;
|
|
private boolean mIsEnabled;
|
|
private String mGroupId;
|
|
|
|
@Override
|
|
public boolean equals(Object o) {
|
|
if (this == o) return true;
|
|
if (o == null || getClass() != o.getClass()) return false;
|
|
PhoneAccount that = (PhoneAccount) o;
|
|
return mCapabilities == that.mCapabilities &&
|
|
mHighlightColor == that.mHighlightColor &&
|
|
mSupportedAudioRoutes == that.mSupportedAudioRoutes &&
|
|
mIsEnabled == that.mIsEnabled &&
|
|
Objects.equals(mAccountHandle, that.mAccountHandle) &&
|
|
Objects.equals(mAddress, that.mAddress) &&
|
|
Objects.equals(mSubscriptionAddress, that.mSubscriptionAddress) &&
|
|
Objects.equals(mLabel, that.mLabel) &&
|
|
Objects.equals(mShortDescription, that.mShortDescription) &&
|
|
Objects.equals(mSupportedUriSchemes, that.mSupportedUriSchemes) &&
|
|
areBundlesEqual(mExtras, that.mExtras) &&
|
|
Objects.equals(mGroupId, that.mGroupId);
|
|
}
|
|
|
|
@Override
|
|
public int hashCode() {
|
|
return Objects.hash(mAccountHandle, mAddress, mSubscriptionAddress, mCapabilities,
|
|
mHighlightColor, mLabel, mShortDescription, mSupportedUriSchemes,
|
|
mSupportedAudioRoutes,
|
|
mExtras, mIsEnabled, mGroupId);
|
|
}
|
|
|
|
/**
|
|
* Helper class for creating a {@link PhoneAccount}.
|
|
*/
|
|
public static class Builder {
|
|
|
|
private PhoneAccountHandle mAccountHandle;
|
|
private Uri mAddress;
|
|
private Uri mSubscriptionAddress;
|
|
private int mCapabilities;
|
|
private int mSupportedAudioRoutes = CallAudioState.ROUTE_ALL;
|
|
private int mHighlightColor = NO_HIGHLIGHT_COLOR;
|
|
private CharSequence mLabel;
|
|
private CharSequence mShortDescription;
|
|
private List<String> mSupportedUriSchemes = new ArrayList<String>();
|
|
private Icon mIcon;
|
|
private Bundle mExtras;
|
|
private boolean mIsEnabled = false;
|
|
private String mGroupId = "";
|
|
|
|
/**
|
|
* Creates a builder with the specified {@link PhoneAccountHandle} and label.
|
|
*/
|
|
public Builder(PhoneAccountHandle accountHandle, CharSequence label) {
|
|
this.mAccountHandle = accountHandle;
|
|
this.mLabel = label;
|
|
}
|
|
|
|
/**
|
|
* Creates an instance of the {@link PhoneAccount.Builder} from an existing
|
|
* {@link PhoneAccount}.
|
|
*
|
|
* @param phoneAccount The {@link PhoneAccount} used to initialize the builder.
|
|
*/
|
|
public Builder(PhoneAccount phoneAccount) {
|
|
mAccountHandle = phoneAccount.getAccountHandle();
|
|
mAddress = phoneAccount.getAddress();
|
|
mSubscriptionAddress = phoneAccount.getSubscriptionAddress();
|
|
mCapabilities = phoneAccount.getCapabilities();
|
|
mHighlightColor = phoneAccount.getHighlightColor();
|
|
mLabel = phoneAccount.getLabel();
|
|
mShortDescription = phoneAccount.getShortDescription();
|
|
mSupportedUriSchemes.addAll(phoneAccount.getSupportedUriSchemes());
|
|
mIcon = phoneAccount.getIcon();
|
|
mIsEnabled = phoneAccount.isEnabled();
|
|
mExtras = phoneAccount.getExtras();
|
|
mGroupId = phoneAccount.getGroupId();
|
|
mSupportedAudioRoutes = phoneAccount.getSupportedAudioRoutes();
|
|
}
|
|
|
|
/**
|
|
* Sets the label. See {@link PhoneAccount#getLabel()}.
|
|
*
|
|
* @param label The label of the phone account.
|
|
* @return The builder.
|
|
* @hide
|
|
*/
|
|
public Builder setLabel(CharSequence label) {
|
|
this.mLabel = label;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets the address. See {@link PhoneAccount#getAddress}.
|
|
*
|
|
* @param value The address of the phone account.
|
|
* @return The builder.
|
|
*/
|
|
public Builder setAddress(Uri value) {
|
|
this.mAddress = value;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets the subscription address. See {@link PhoneAccount#getSubscriptionAddress}.
|
|
*
|
|
* @param value The subscription address.
|
|
* @return The builder.
|
|
*/
|
|
public Builder setSubscriptionAddress(Uri value) {
|
|
this.mSubscriptionAddress = value;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets the capabilities. See {@link PhoneAccount#getCapabilities}.
|
|
*
|
|
* @param value The capabilities to set.
|
|
* @return The builder.
|
|
*/
|
|
public Builder setCapabilities(int value) {
|
|
this.mCapabilities = value;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets the icon. See {@link PhoneAccount#getIcon}.
|
|
*
|
|
* @param icon The icon to set.
|
|
*/
|
|
public Builder setIcon(Icon icon) {
|
|
mIcon = icon;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets the highlight color. See {@link PhoneAccount#getHighlightColor}.
|
|
*
|
|
* @param value The highlight color.
|
|
* @return The builder.
|
|
*/
|
|
public Builder setHighlightColor(int value) {
|
|
this.mHighlightColor = value;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets the short description. See {@link PhoneAccount#getShortDescription}.
|
|
*
|
|
* @param value The short description.
|
|
* @return The builder.
|
|
*/
|
|
public Builder setShortDescription(CharSequence value) {
|
|
this.mShortDescription = value;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Specifies an additional URI scheme supported by the {@link PhoneAccount}.
|
|
*
|
|
* @param uriScheme The URI scheme.
|
|
* @return The builder.
|
|
*/
|
|
public Builder addSupportedUriScheme(String uriScheme) {
|
|
if (!TextUtils.isEmpty(uriScheme) && !mSupportedUriSchemes.contains(uriScheme)) {
|
|
this.mSupportedUriSchemes.add(uriScheme);
|
|
}
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Specifies the URI schemes supported by the {@link PhoneAccount}.
|
|
*
|
|
* @param uriSchemes The URI schemes.
|
|
* @return The builder.
|
|
*/
|
|
public Builder setSupportedUriSchemes(List<String> uriSchemes) {
|
|
mSupportedUriSchemes.clear();
|
|
|
|
if (uriSchemes != null && !uriSchemes.isEmpty()) {
|
|
for (String uriScheme : uriSchemes) {
|
|
addSupportedUriScheme(uriScheme);
|
|
}
|
|
}
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Specifies the extras associated with the {@link PhoneAccount}.
|
|
* <p>
|
|
* {@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.
|
|
* <p>
|
|
* 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<String> supportedUriSchemes,
|
|
Bundle extras,
|
|
int supportedAudioRoutes,
|
|
boolean isEnabled,
|
|
String groupId) {
|
|
mAccountHandle = account;
|
|
mAddress = address;
|
|
mSubscriptionAddress = subscriptionAddress;
|
|
mCapabilities = capabilities;
|
|
mIcon = icon;
|
|
mHighlightColor = highlightColor;
|
|
mLabel = label;
|
|
mShortDescription = shortDescription;
|
|
mSupportedUriSchemes = Collections.unmodifiableList(supportedUriSchemes);
|
|
mExtras = extras;
|
|
mSupportedAudioRoutes = supportedAudioRoutes;
|
|
mIsEnabled = isEnabled;
|
|
mGroupId = groupId;
|
|
}
|
|
|
|
public static Builder builder(
|
|
PhoneAccountHandle accountHandle,
|
|
CharSequence label) {
|
|
return new Builder(accountHandle, label);
|
|
}
|
|
|
|
/**
|
|
* Returns a builder initialized with the current {@link PhoneAccount} instance.
|
|
*
|
|
* @return The builder.
|
|
*/
|
|
public Builder toBuilder() { return new Builder(this); }
|
|
|
|
/**
|
|
* The unique identifier of this {@code PhoneAccount}.
|
|
*
|
|
* @return A {@code PhoneAccountHandle}.
|
|
*/
|
|
public PhoneAccountHandle getAccountHandle() {
|
|
return mAccountHandle;
|
|
}
|
|
|
|
/**
|
|
* The address (e.g., a phone number) associated with this {@code PhoneAccount}. This
|
|
* represents the destination from which outgoing calls using this {@code PhoneAccount}
|
|
* will appear to come, if applicable, and the destination to which incoming calls using this
|
|
* {@code PhoneAccount} may be addressed.
|
|
*
|
|
* @return A address expressed as a {@code Uri}, for example, a phone number.
|
|
*/
|
|
public Uri getAddress() {
|
|
return mAddress;
|
|
}
|
|
|
|
/**
|
|
* The raw callback number used for this {@code PhoneAccount}, as distinct from
|
|
* {@link #getAddress()}. For the majority of {@code PhoneAccount}s this should be registered
|
|
* as {@code null}. It is used by the system for SIM-based {@code PhoneAccount} registration
|
|
* where {@link android.telephony.TelephonyManager#setLine1NumberForDisplay(String, String)}
|
|
* has been used to alter the callback number.
|
|
* <p>
|
|
*
|
|
* @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<String> getSupportedUriSchemes() {
|
|
return mSupportedUriSchemes;
|
|
}
|
|
|
|
/**
|
|
* The extras associated with this {@code PhoneAccount}.
|
|
* <p>
|
|
* 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<PhoneAccount> CREATOR
|
|
= new Creator<PhoneAccount>() {
|
|
@Override
|
|
public PhoneAccount createFromParcel(Parcel in) {
|
|
return new PhoneAccount(in);
|
|
}
|
|
|
|
@Override
|
|
public PhoneAccount[] newArray(int size) {
|
|
return new PhoneAccount[size];
|
|
}
|
|
};
|
|
|
|
private PhoneAccount(Parcel in) {
|
|
if (in.readInt() > 0) {
|
|
mAccountHandle = PhoneAccountHandle.CREATOR.createFromParcel(in);
|
|
} else {
|
|
mAccountHandle = null;
|
|
}
|
|
if (in.readInt() > 0) {
|
|
mAddress = Uri.CREATOR.createFromParcel(in);
|
|
} else {
|
|
mAddress = null;
|
|
}
|
|
if (in.readInt() > 0) {
|
|
mSubscriptionAddress = Uri.CREATOR.createFromParcel(in);
|
|
} else {
|
|
mSubscriptionAddress = null;
|
|
}
|
|
mCapabilities = in.readInt();
|
|
mHighlightColor = in.readInt();
|
|
mLabel = in.readCharSequence();
|
|
mShortDescription = in.readCharSequence();
|
|
mSupportedUriSchemes = Collections.unmodifiableList(in.createStringArrayList());
|
|
if (in.readInt() > 0) {
|
|
mIcon = Icon.CREATOR.createFromParcel(in);
|
|
} else {
|
|
mIcon = null;
|
|
}
|
|
mIsEnabled = in.readByte() == 1;
|
|
mExtras = in.readBundle();
|
|
mGroupId = in.readString();
|
|
mSupportedAudioRoutes = in.readInt();
|
|
}
|
|
|
|
@Override
|
|
public String toString() {
|
|
StringBuilder sb = new StringBuilder().append("[[")
|
|
.append(mIsEnabled ? 'X' : ' ')
|
|
.append("] PhoneAccount: ")
|
|
.append(mAccountHandle)
|
|
.append(" Capabilities: ")
|
|
.append(capabilitiesToString())
|
|
.append(" Audio Routes: ")
|
|
.append(audioRoutesToString())
|
|
.append(" Schemes: ");
|
|
for (String scheme : mSupportedUriSchemes) {
|
|
sb.append(scheme)
|
|
.append(" ");
|
|
}
|
|
sb.append(" Extras: ");
|
|
sb.append(mExtras);
|
|
sb.append(" GroupId: ");
|
|
sb.append(Log.pii(mGroupId));
|
|
sb.append("]");
|
|
return sb.toString();
|
|
}
|
|
|
|
/**
|
|
* Generates a string representation of a capabilities bitmask.
|
|
*
|
|
* @return String representation of the capabilities bitmask.
|
|
* @hide
|
|
*/
|
|
public String capabilitiesToString() {
|
|
StringBuilder sb = new StringBuilder();
|
|
if (hasCapabilities(CAPABILITY_SELF_MANAGED)) {
|
|
sb.append("SelfManaged ");
|
|
}
|
|
if (hasCapabilities(CAPABILITY_SUPPORTS_VIDEO_CALLING)) {
|
|
sb.append("SuppVideo ");
|
|
}
|
|
if (hasCapabilities(CAPABILITY_VIDEO_CALLING)) {
|
|
sb.append("Video ");
|
|
}
|
|
if (hasCapabilities(CAPABILITY_VIDEO_CALLING_RELIES_ON_PRESENCE)) {
|
|
sb.append("Presence ");
|
|
}
|
|
if (hasCapabilities(CAPABILITY_CALL_PROVIDER)) {
|
|
sb.append("CallProvider ");
|
|
}
|
|
if (hasCapabilities(CAPABILITY_CALL_SUBJECT)) {
|
|
sb.append("CallSubject ");
|
|
}
|
|
if (hasCapabilities(CAPABILITY_CONNECTION_MANAGER)) {
|
|
sb.append("ConnectionMgr ");
|
|
}
|
|
if (hasCapabilities(CAPABILITY_EMERGENCY_CALLS_ONLY)) {
|
|
sb.append("EmergOnly ");
|
|
}
|
|
if (hasCapabilities(CAPABILITY_MULTI_USER)) {
|
|
sb.append("MultiUser ");
|
|
}
|
|
if (hasCapabilities(CAPABILITY_PLACE_EMERGENCY_CALLS)) {
|
|
sb.append("PlaceEmerg ");
|
|
}
|
|
if (hasCapabilities(CAPABILITY_EMERGENCY_PREFERRED)) {
|
|
sb.append("EmerPrefer ");
|
|
}
|
|
if (hasCapabilities(CAPABILITY_EMERGENCY_VIDEO_CALLING)) {
|
|
sb.append("EmergVideo ");
|
|
}
|
|
if (hasCapabilities(CAPABILITY_SIM_SUBSCRIPTION)) {
|
|
sb.append("SimSub ");
|
|
}
|
|
if (hasCapabilities(CAPABILITY_RTT)) {
|
|
sb.append("Rtt ");
|
|
}
|
|
if (hasCapabilities(CAPABILITY_ADHOC_CONFERENCE_CALLING)) {
|
|
sb.append("AdhocConf ");
|
|
}
|
|
if (hasCapabilities(CAPABILITY_CALL_COMPOSER)) {
|
|
sb.append("CallComposer ");
|
|
}
|
|
if (hasCapabilities(CAPABILITY_SUPPORTS_VOICE_CALLING_INDICATIONS)) {
|
|
sb.append("SuppVoice ");
|
|
}
|
|
if (hasCapabilities(CAPABILITY_VOICE_CALLING_AVAILABLE)) {
|
|
sb.append("Voice ");
|
|
}
|
|
return sb.toString();
|
|
}
|
|
|
|
private String audioRoutesToString() {
|
|
StringBuilder sb = new StringBuilder();
|
|
|
|
if (hasAudioRoutes(CallAudioState.ROUTE_BLUETOOTH)) {
|
|
sb.append("B");
|
|
}
|
|
if (hasAudioRoutes(CallAudioState.ROUTE_EARPIECE)) {
|
|
sb.append("E");
|
|
}
|
|
if (hasAudioRoutes(CallAudioState.ROUTE_SPEAKER)) {
|
|
sb.append("S");
|
|
}
|
|
if (hasAudioRoutes(CallAudioState.ROUTE_WIRED_HEADSET)) {
|
|
sb.append("W");
|
|
}
|
|
|
|
return sb.toString();
|
|
}
|
|
|
|
/**
|
|
* Determines if two {@link Bundle}s are equal.
|
|
* @param extras First {@link Bundle} to check.
|
|
* @param newExtras {@link Bundle} to compare against.
|
|
* @return {@code true} if the {@link Bundle}s are equal, {@code false} otherwise.
|
|
*/
|
|
private static boolean areBundlesEqual(Bundle extras, Bundle newExtras) {
|
|
if (extras == null || newExtras == null) {
|
|
return extras == newExtras;
|
|
}
|
|
|
|
if (extras.size() != newExtras.size()) {
|
|
return false;
|
|
}
|
|
|
|
for(String key : extras.keySet()) {
|
|
if (key != null) {
|
|
final Object value = extras.get(key);
|
|
final Object newValue = newExtras.get(key);
|
|
if (!Objects.equals(value, newValue)) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
}
|