diff options
Diffstat (limited to 'telecomm/java/android/telecom/PhoneAccount.java')
| -rw-r--r-- | telecomm/java/android/telecom/PhoneAccount.java | 490 |
1 files changed, 490 insertions, 0 deletions
diff --git a/telecomm/java/android/telecom/PhoneAccount.java b/telecomm/java/android/telecom/PhoneAccount.java new file mode 100644 index 0000000..0c233eb --- /dev/null +++ b/telecomm/java/android/telecom/PhoneAccount.java @@ -0,0 +1,490 @@ +/* + * 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.content.Context; +import android.content.pm.PackageManager; +import android.content.res.Resources.NotFoundException; +import android.graphics.drawable.Drawable; +import android.net.Uri; +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; + +/** + * Describes a distinct account, line of service or call placement method that the system + * can use to place phone calls. + */ +public class PhoneAccount implements Parcelable { + + /** + * 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 + * calls from or use the built-in telephony stack to place its calls. + * <p> + * See {@link #getCapabilities} + * <p> + * {@hide} + */ + 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} + * @hide + */ + 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 always enabled and cannot be disabled by + * the user. + * This capability is reserved for important {@code PhoneAccount}s such as the emergency calling + * only {@code PhoneAccount}. + * <p> + * See {@link #getCapabilities} + * @hide + */ + public static final int CAPABILITY_ALWAYS_ENABLED = 0x20; + + /** + * 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"; + + private final PhoneAccountHandle mAccountHandle; + private final Uri mAddress; + private final Uri mSubscriptionAddress; + private final int mCapabilities; + private final int mIconResId; + private final CharSequence mLabel; + private final CharSequence mShortDescription; + private final List<String> mSupportedUriSchemes; + private final boolean mIsEnabled; + + public static class Builder { + private PhoneAccountHandle mAccountHandle; + private Uri mAddress; + private Uri mSubscriptionAddress; + private int mCapabilities; + private int mIconResId; + private CharSequence mLabel; + private CharSequence mShortDescription; + private List<String> mSupportedUriSchemes = new ArrayList<String>(); + private boolean mIsEnabled = false; + + 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(); + mIconResId = phoneAccount.getIconResId(); + mLabel = phoneAccount.getLabel(); + mShortDescription = phoneAccount.getShortDescription(); + mSupportedUriSchemes.addAll(phoneAccount.getSupportedUriSchemes()); + mIsEnabled = phoneAccount.isEnabled(); + } + + public Builder setAddress(Uri value) { + this.mAddress = value; + return this; + } + + public Builder setSubscriptionAddress(Uri value) { + this.mSubscriptionAddress = value; + return this; + } + + public Builder setCapabilities(int value) { + this.mCapabilities = value; + return this; + } + + public Builder setIconResId(int value) { + this.mIconResId = value; + return this; + } + + 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. + * @hide + */ + 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 whether the {@link PhoneAccount} is enabled or not. {@link PhoneAccount}s are + * by default not enabled. + * + * @param value {@code True} if the {@link PhoneAccount} is enabled. + * @return The Builder. + * @hide + */ + public Builder setEnabled(boolean value) { + this.mIsEnabled = value; + 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, + mIconResId, + mLabel, + mShortDescription, + mSupportedUriSchemes, + mIsEnabled); + } + } + + private PhoneAccount( + PhoneAccountHandle account, + Uri address, + Uri subscriptionAddress, + int capabilities, + int iconResId, + CharSequence label, + CharSequence shortDescription, + List<String> supportedUriSchemes, + boolean enabled) { + mAccountHandle = account; + mAddress = address; + mSubscriptionAddress = subscriptionAddress; + mCapabilities = capabilities; + mIconResId = iconResId; + mLabel = label; + mShortDescription = shortDescription; + mSupportedUriSchemes = Collections.unmodifiableList(supportedUriSchemes); + mIsEnabled = enabled; + } + + 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. + * @hide + */ + 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; + } + + /** + * 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; + } + + /** + * Determines whether this {@code PhoneAccount} is enabled. + * + * @return {@code True} if this {@code PhoneAccount} is enabled.. + */ + public boolean isEnabled() { + return mIsEnabled; + } + + /** + * The icon resource ID for the icon of this {@code PhoneAccount}. + * + * @return A resource ID. + */ + public int getIconResId() { + return mIconResId; + } + + /** + * An icon to represent this {@code PhoneAccount} in a user interface. + * + * @return An icon for this {@code PhoneAccount}. + */ + public Drawable getIcon(Context context) { + return getIcon(context, mIconResId); + } + + private Drawable getIcon(Context context, int resId) { + Context packageContext; + try { + packageContext = context.createPackageContext( + mAccountHandle.getComponentName().getPackageName(), 0); + } catch (PackageManager.NameNotFoundException e) { + Log.w(this, "Cannot find package %s", mAccountHandle.getComponentName().getPackageName()); + return null; + } + try { + return packageContext.getDrawable(resId); + } catch (NotFoundException|MissingResourceException e) { + Log.e(this, e, "Cannot find icon %d in package %s", + resId, mAccountHandle.getComponentName().getPackageName()); + return null; + } + } + + // + // Parcelable implementation + // + + @Override + public int describeContents() { + return 0; + } + + @Override + public void writeToParcel(Parcel out, int flags) { + out.writeParcelable(mAccountHandle, 0); + out.writeParcelable(mAddress, 0); + out.writeParcelable(mSubscriptionAddress, 0); + out.writeInt(mCapabilities); + out.writeInt(mIconResId); + out.writeCharSequence(mLabel); + out.writeCharSequence(mShortDescription); + out.writeList(mSupportedUriSchemes); + out.writeInt(mIsEnabled ? 1 : 0); + } + + 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) { + ClassLoader classLoader = PhoneAccount.class.getClassLoader(); + + mAccountHandle = in.readParcelable(getClass().getClassLoader()); + mAddress = in.readParcelable(getClass().getClassLoader()); + mSubscriptionAddress = in.readParcelable(getClass().getClassLoader()); + mCapabilities = in.readInt(); + mIconResId = in.readInt(); + mLabel = in.readCharSequence(); + mShortDescription = in.readCharSequence(); + + List<String> supportedUriSchemes = new ArrayList<>(); + in.readList(supportedUriSchemes, classLoader); + mSupportedUriSchemes = Collections.unmodifiableList(supportedUriSchemes); + mIsEnabled = in.readInt() == 1; + } +} |