telecomm/java/android/telecom/PhoneAccount.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.FlaggedApi;
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 android.util.ArraySet;

import com.android.internal.telephony.flags.Flags;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Objects;
import java.util.Set;

/**
 * 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
     */
    @SystemApi
    @FlaggedApi(com.android.server.telecom.flags.Flags.FLAG_TELECOM_RESOLVE_HIDDEN_DEPENDENCIES)
    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;


    /**
     * Flag indicating that this {@link PhoneAccount} supports the use TelecomManager APIs that
     * utilize {@link android.os.OutcomeReceiver}s or {@link java.util.function.Consumer}s.
     * Be aware, if this capability is set, {@link #CAPABILITY_SELF_MANAGED} will be amended by
     * Telecom when this {@link PhoneAccount} is registered via
     * {@link TelecomManager#registerPhoneAccount(PhoneAccount)}.
     *
     * <p>
     * {@link android.os.OutcomeReceiver}s and {@link java.util.function.Consumer}s represent
     * transactional operations because the operation can succeed or fail.  An app wishing to use
     * transactional operations should define behavior for a successful and failed TelecomManager
     * API call.
     *
     * @see #CAPABILITY_SELF_MANAGED
     * @see #getCapabilities
     */
    public static final int CAPABILITY_SUPPORTS_TRANSACTIONAL_OPERATIONS = 0x40000;

    /**
     * Flag indicating that this voip app {@link PhoneAccount} supports the call streaming session
     * to stream call audio to another remote device via streaming app.
     *
     * @see #getCapabilities
     */
    public static final int CAPABILITY_SUPPORTS_CALL_STREAMING = 0x80000;

    /* NEXT CAPABILITY: [0x100000, 0x200000, 0x400000] */

    /**
     * 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;
    private final Set<PhoneAccountHandle> mSimultaneousCallingRestriction;

    @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)
                && Objects.equals(mSimultaneousCallingRestriction,
                        that.mSimultaneousCallingRestriction);
    }

    @Override
    public int hashCode() {
        return Objects.hash(mAccountHandle, mAddress, mSubscriptionAddress, mCapabilities,
                mHighlightColor, mLabel, mShortDescription, mSupportedUriSchemes,
                mSupportedAudioRoutes,
                mExtras, mIsEnabled, mGroupId, mSimultaneousCallingRestriction);
    }

    /**
     * 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 = "";
        private Set<PhoneAccountHandle> mSimultaneousCallingRestriction = null;

        /**
         * Creates a builder with the specified {@link PhoneAccountHandle} and label.
         * <p>
         * Note: each CharSequence or String field is limited to 256 characters. This check is
         * enforced when registering the PhoneAccount via
         * {@link TelecomManager#registerPhoneAccount(PhoneAccount)} and will cause an
         * {@link IllegalArgumentException} to be thrown if the character field limit is over 256.
         */
        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();
            if (phoneAccount.hasSimultaneousCallingRestriction()) {
                mSimultaneousCallingRestriction = phoneAccount.getSimultaneousCallingRestriction();
            }
        }

        /**
         * Sets the label. See {@link PhoneAccount#getLabel()}.
         * <p>
         * Note: Each CharSequence or String field is limited to 256 characters. This check is
         * enforced when registering the PhoneAccount via
         * {@link TelecomManager#registerPhoneAccount(PhoneAccount)} and will cause an
         * {@link IllegalArgumentException} to be thrown if the character field limit is over 256.
         *
         * @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}.
         * <p>
         * Note: The entire URI value is limited to 256 characters. This check is
         * enforced when registering the PhoneAccount via
         * {@link TelecomManager#registerPhoneAccount(PhoneAccount)} and will cause an
         * {@link IllegalArgumentException} to be thrown if URI is over 256.
         *
         * @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}.
         * <p>
         * Note: An {@link IllegalArgumentException} if the Icon cannot be written to memory.
         * This check is enforced when registering the PhoneAccount via
         * {@link TelecomManager#registerPhoneAccount(PhoneAccount)}
         *
         * @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}.
         * <p>
         * Note: Each CharSequence or String field is limited to 256 characters. This check is
         * enforced when registering the PhoneAccount via
         * {@link TelecomManager#registerPhoneAccount(PhoneAccount)} and will cause an
         * {@link IllegalArgumentException} to be thrown if the character field limit is over 256.
         *
         * @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}.
         *
         * <p>
         * Each URI scheme is limited to 256 characters.  Adding a scheme over 256 characters will
         * cause an {@link IllegalArgumentException} to be thrown when the account is registered.
         *
         * @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}.
         *
         * <p>
         * A max of 10 URI schemes can be added per account.  Additionally, each URI scheme is
         * limited to 256 characters. Adding more than 10 URI schemes or 256 characters on any
         * scheme will cause an {@link IllegalArgumentException} to be thrown when the account
         * is registered.
         *
         * @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.
         * <p>
         * Note: Each Bundle (Key, Value) String field is limited to 256 characters. Additionally,
         * the bundle is limited to 100 (Key, Value) pairs total.  This check is
         * enforced when registering the PhoneAccount via
         * {@link TelecomManager#registerPhoneAccount(PhoneAccount)} and will cause an
         * {@link IllegalArgumentException} to be thrown if the character field limit is over 256
         * or more than 100 (Key, Value) pairs are in the Bundle.
         *
         * @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.
         * <p>
         * Additionally, each CharSequence or String field is limited to 256 characters.
         * This check is enforced when registering the PhoneAccount via
         * {@link TelecomManager#registerPhoneAccount(PhoneAccount)} and will cause an
         * {@link IllegalArgumentException} to be thrown if the character field limit is over 256.
         *
         * @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;
        }

        /**
         * Restricts the ability of this {@link PhoneAccount} to ONLY support simultaneous calling
         * with the other {@link PhoneAccountHandle}s in this Set.
         * <p>
         * If two or more {@link PhoneAccount}s support calling simultaneously, it means that
         * Telecom allows the user to place additional outgoing calls and receive additional
         * incoming calls using other {@link PhoneAccount}s while this PhoneAccount also has one or
         * more active calls.
         * <p>
         * If this setter method is never called or cleared using
         * {@link #clearSimultaneousCallingRestriction()}, there is no restriction and all
         * {@link PhoneAccount}s registered to Telecom by this package support simultaneous calling.
         * <p>
         * Note: Simultaneous calling restrictions can only be placed on {@link PhoneAccount}s that
         * were registered by the same application. Simultaneous calling across applications is
         * always possible as long as the {@link Connection} supports hold. If a
         * {@link PhoneAccountHandle} is included here and the package name doesn't match this
         * application's package name, {@link TelecomManager#registerPhoneAccount(PhoneAccount)}
         * will throw a {@link SecurityException}.
         *
         * @param handles The other {@link PhoneAccountHandle}s that support calling simultaneously
         * with this one. Use {@link #clearSimultaneousCallingRestriction()} to remove the
         * restriction and allow simultaneous calling to be supported across all
         * {@link PhoneAccount}s registered by this package.
         * @return The Builder used to set up the new PhoneAccount.
         */
        @FlaggedApi(Flags.FLAG_SIMULTANEOUS_CALLING_INDICATIONS)
        public @NonNull Builder setSimultaneousCallingRestriction(
                @NonNull Set<PhoneAccountHandle> handles) {
            if (handles == null) {
                throw new IllegalArgumentException("the Set of PhoneAccountHandles must not be "
                        + "null");
            }
            mSimultaneousCallingRestriction = handles;
            return this;
        }

        /**
         * Clears a previously set simultaneous calling restriction set when
         * {@link PhoneAccount.Builder#Builder(PhoneAccount)} is used to create a new PhoneAccount
         * from an existing one.
         *
         * @return The Builder used to set up the new PhoneAccount.
         * @see #setSimultaneousCallingRestriction(Set)
         */
        @FlaggedApi(Flags.FLAG_SIMULTANEOUS_CALLING_INDICATIONS)
        public @NonNull Builder clearSimultaneousCallingRestriction() {
            mSimultaneousCallingRestriction = null;
            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,
                    mSimultaneousCallingRestriction);
        }
    }

    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,
            Set<PhoneAccountHandle> simultaneousCallingRestriction) {
        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;
        mSimultaneousCallingRestriction = simultaneousCallingRestriction;
    }

    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;
    }

    /**
     * If a restriction is set (see {@link #hasSimultaneousCallingRestriction()}), this method
     * returns the Set of {@link PhoneAccountHandle}s that are allowed to support calls
     * simultaneously with this {@link PhoneAccount}.
     * <p>
     * If this {@link PhoneAccount} is busy with one or more ongoing calls, a restriction is set on
     * this PhoneAccount (see {@link #hasSimultaneousCallingRestriction()} to check),  and a new
     * incoming or outgoing call is received or placed on a PhoneAccount that is not in this Set,
     * Telecom will reject or cancel the pending call in favor of keeping the ongoing call alive.
     * <p>
     * Note: Simultaneous calling restrictions can only be placed on {@link PhoneAccount}s that
     * were registered by the same application. Simultaneous calling across applications is
     * always possible as long as the {@link Connection} supports hold.
     *
     * @return the Set of {@link PhoneAccountHandle}s that this {@link PhoneAccount} supports
     * simultaneous calls with.
     * @throws IllegalStateException If there is no restriction set on this {@link PhoneAccount}
     * and this method is called. Whether or not there is a restriction can be checked using
     * {@link #hasSimultaneousCallingRestriction()}.
     */
    @FlaggedApi(Flags.FLAG_SIMULTANEOUS_CALLING_INDICATIONS)
    public @NonNull Set<PhoneAccountHandle> getSimultaneousCallingRestriction() {
        if (mSimultaneousCallingRestriction == null) {
            throw new IllegalStateException("This method can not be called if there is no "
                    + "simultaneous calling restriction. See #hasSimultaneousCallingRestriction");
        }
        return mSimultaneousCallingRestriction;
    }

    /**
     * Whether or not this {@link PhoneAccount} contains a simultaneous calling restriction on it.
     *
     * @return {@code true} if this PhoneAccount contains a simultaneous calling restriction,
     * {@code false} if it does not. Use {@link #getSimultaneousCallingRestriction()} to query which
     * other {@link PhoneAccount}s support simultaneous calling with this one.
     * @see #getSimultaneousCallingRestriction() for more information on how the sinultaneous
     * calling restriction works.
     */
    @FlaggedApi(Flags.FLAG_SIMULTANEOUS_CALLING_INDICATIONS)
    public boolean hasSimultaneousCallingRestriction() {
        return mSimultaneousCallingRestriction != null;
    }

    //
    // 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);
        if (mSimultaneousCallingRestriction == null) {
            out.writeBoolean(false);
        } else {
            out.writeBoolean(true);
            out.writeTypedList(mSimultaneousCallingRestriction.stream().toList());
        }
    }

    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();
        if (in.readBoolean()) {
            List<PhoneAccountHandle> list = new ArrayList<>();
            in.readTypedList(list, PhoneAccountHandle.CREATOR);
            mSimultaneousCallingRestriction = new ArraySet<>(list);
        } else {
            mSimultaneousCallingRestriction = null;
        }
    }

    @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(" SC Restrictions: ");
        if (hasSimultaneousCallingRestriction()) {
            sb.append("[ ");
            for (PhoneAccountHandle handle : mSimultaneousCallingRestriction) {
                sb.append(handle);
                sb.append(" ");
            }
            sb.append("]");
        } else {
            sb.append("[NONE]");
        }
        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 ");
        }
        if (hasCapabilities(CAPABILITY_SUPPORTS_TRANSACTIONAL_OPERATIONS)) {
            sb.append("TransactOps ");
        }
        if (hasCapabilities(CAPABILITY_SUPPORTS_CALL_STREAMING)) {
            sb.append("Stream ");
        }
        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;
    }
}