9a365756b3
Added new PhoneAccount capability used to indicate whether the dialer should use the presence bit in the contacts provider to determine when the video call icon is shown or not. Bug: 20257833 Change-Id: Ifb3cc5b7ff1090d539dfb925dce9f6327de15c46
702 lines
23 KiB
Java
702 lines
23 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 android.annotation.SystemApi;
|
|
import android.content.ComponentName;
|
|
import android.content.Context;
|
|
import android.content.pm.PackageManager;
|
|
import android.content.res.Resources.NotFoundException;
|
|
import android.graphics.Bitmap;
|
|
import android.graphics.Color;
|
|
import android.graphics.drawable.BitmapDrawable;
|
|
import android.graphics.drawable.ColorDrawable;
|
|
import android.graphics.drawable.Drawable;
|
|
import android.graphics.drawable.Icon;
|
|
import android.net.Uri;
|
|
import android.os.Bundle;
|
|
import android.os.Parcel;
|
|
import android.os.Parcelable;
|
|
import android.text.TextUtils;
|
|
|
|
import java.lang.String;
|
|
import java.util.ArrayList;
|
|
import java.util.Collections;
|
|
import java.util.List;
|
|
import java.util.MissingResourceException;
|
|
|
|
/**
|
|
* 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 {
|
|
|
|
/**
|
|
* {@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";
|
|
|
|
/**
|
|
* 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 capable of 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
|
|
*/
|
|
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>
|
|
* When set, the {@link ConnectionService} is responsible for toggling 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.
|
|
* <p>
|
|
* See {@link #getCapabilities}
|
|
*/
|
|
public static final int CAPABILITY_VIDEO_CALLING_RELIES_ON_PRESENCE = 0x100;
|
|
|
|
/**
|
|
* 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 Icon mIcon;
|
|
private final Bundle mExtras;
|
|
private boolean mIsEnabled;
|
|
|
|
/**
|
|
* 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 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;
|
|
|
|
/**
|
|
* 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();
|
|
}
|
|
|
|
/**
|
|
* 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;
|
|
}
|
|
|
|
/**
|
|
* 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,
|
|
mIsEnabled);
|
|
}
|
|
}
|
|
|
|
private PhoneAccount(
|
|
PhoneAccountHandle account,
|
|
Uri address,
|
|
Uri subscriptionAddress,
|
|
int capabilities,
|
|
Icon icon,
|
|
int highlightColor,
|
|
CharSequence label,
|
|
CharSequence shortDescription,
|
|
List<String> supportedUriSchemes,
|
|
Bundle extras,
|
|
boolean isEnabled) {
|
|
mAccountHandle = account;
|
|
mAddress = address;
|
|
mSubscriptionAddress = subscriptionAddress;
|
|
mCapabilities = capabilities;
|
|
mIcon = icon;
|
|
mHighlightColor = highlightColor;
|
|
mLabel = label;
|
|
mShortDescription = shortDescription;
|
|
mSupportedUriSchemes = Collections.unmodifiableList(supportedUriSchemes);
|
|
mExtras = extras;
|
|
mIsEnabled = isEnabled;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
/**
|
|
* 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 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;
|
|
}
|
|
|
|
/**
|
|
* 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;
|
|
}
|
|
|
|
//
|
|
// 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);
|
|
}
|
|
|
|
public static final 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();
|
|
}
|
|
|
|
@Override
|
|
public String toString() {
|
|
StringBuilder sb = new StringBuilder().append("[[")
|
|
.append(mIsEnabled ? 'X' : ' ')
|
|
.append("] PhoneAccount: ")
|
|
.append(mAccountHandle)
|
|
.append(" Capabilities: ")
|
|
.append(mCapabilities)
|
|
.append(" Schemes: ");
|
|
for (String scheme : mSupportedUriSchemes) {
|
|
sb.append(scheme)
|
|
.append(" ");
|
|
}
|
|
sb.append(" Extras: ");
|
|
sb.append(mExtras);
|
|
sb.append("]");
|
|
return sb.toString();
|
|
}
|
|
}
|