1 /* 2 * Copyright (C) 2014 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package android.telecom; 18 19 import android.annotation.SystemApi; 20 import android.content.ComponentName; 21 import android.content.Context; 22 import android.content.pm.PackageManager; 23 import android.content.res.Resources.NotFoundException; 24 import android.graphics.Bitmap; 25 import android.graphics.Color; 26 import android.graphics.drawable.BitmapDrawable; 27 import android.graphics.drawable.ColorDrawable; 28 import android.graphics.drawable.Drawable; 29 import android.graphics.drawable.Icon; 30 import android.net.Uri; 31 import android.os.Bundle; 32 import android.os.Parcel; 33 import android.os.Parcelable; 34 import android.text.TextUtils; 35 36 import java.lang.String; 37 import java.util.ArrayList; 38 import java.util.Collections; 39 import java.util.List; 40 import java.util.MissingResourceException; 41 42 /** 43 * Represents a distinct method to place or receive a phone call. Apps which can place calls and 44 * want those calls to be integrated into the dialer and in-call UI should build an instance of 45 * this class and register it with the system using {@link TelecomManager}. 46 * <p> 47 * {@link TelecomManager} uses registered {@link PhoneAccount}s to present the user with 48 * alternative options when placing a phone call. When building a {@link PhoneAccount}, the app 49 * should supply a valid {@link PhoneAccountHandle} that references the connection service 50 * implementation Telecom will use to interact with the app. 51 */ 52 public final class PhoneAccount implements Parcelable { 53 54 /** 55 * {@link PhoneAccount} extras key (see {@link PhoneAccount#getExtras()}) which determines the 56 * maximum permitted length of a call subject specified via the 57 * {@link TelecomManager#EXTRA_CALL_SUBJECT} extra on an 58 * {@link android.content.Intent#ACTION_CALL} intent. Ultimately a {@link ConnectionService} is 59 * responsible for enforcing the maximum call subject length when sending the message, however 60 * this extra is provided so that the user interface can proactively limit the length of the 61 * call subject as the user types it. 62 */ 63 public static final String EXTRA_CALL_SUBJECT_MAX_LENGTH = 64 "android.telecom.extra.CALL_SUBJECT_MAX_LENGTH"; 65 66 /** 67 * {@link PhoneAccount} extras key (see {@link PhoneAccount#getExtras()}) which determines the 68 * character encoding to be used when determining the length of messages. 69 * The user interface can use this when determining the number of characters the user may type 70 * in a call subject. If empty-string, the call subject message size limit will be enforced on 71 * a 1:1 basis. That is, each character will count towards the messages size limit as a single 72 * character. If a character encoding is specified, the message size limit will be based on the 73 * number of bytes in the message per the specified encoding. See 74 * {@link #EXTRA_CALL_SUBJECT_MAX_LENGTH} for more information on the call subject maximum 75 * length. 76 */ 77 public static final String EXTRA_CALL_SUBJECT_CHARACTER_ENCODING = 78 "android.telecom.extra.CALL_SUBJECT_CHARACTER_ENCODING"; 79 80 /** 81 * Flag indicating that this {@code PhoneAccount} can act as a connection manager for 82 * other connections. The {@link ConnectionService} associated with this {@code PhoneAccount} 83 * will be allowed to manage phone calls including using its own proprietary phone-call 84 * implementation (like VoIP calling) to make calls instead of the telephony stack. 85 * <p> 86 * When a user opts to place a call using the SIM-based telephony stack, the 87 * {@link ConnectionService} associated with this {@code PhoneAccount} will be attempted first 88 * if the user has explicitly selected it to be used as the default connection manager. 89 * <p> 90 * See {@link #getCapabilities} 91 */ 92 public static final int CAPABILITY_CONNECTION_MANAGER = 0x1; 93 94 /** 95 * Flag indicating that this {@code PhoneAccount} can make phone calls in place of 96 * traditional SIM-based telephony calls. This account will be treated as a distinct method 97 * for placing calls alongside the traditional SIM-based telephony stack. This flag is 98 * distinct from {@link #CAPABILITY_CONNECTION_MANAGER} in that it is not allowed to manage 99 * or place calls from the built-in telephony stack. 100 * <p> 101 * See {@link #getCapabilities} 102 * <p> 103 */ 104 public static final int CAPABILITY_CALL_PROVIDER = 0x2; 105 106 /** 107 * Flag indicating that this {@code PhoneAccount} represents a built-in PSTN SIM 108 * subscription. 109 * <p> 110 * Only the Android framework can register a {@code PhoneAccount} having this capability. 111 * <p> 112 * See {@link #getCapabilities} 113 */ 114 public static final int CAPABILITY_SIM_SUBSCRIPTION = 0x4; 115 116 /** 117 * Flag indicating that this {@code PhoneAccount} is capable of placing video calls. 118 * <p> 119 * See {@link #getCapabilities} 120 */ 121 public static final int CAPABILITY_VIDEO_CALLING = 0x8; 122 123 /** 124 * Flag indicating that this {@code PhoneAccount} is capable of placing emergency calls. 125 * By default all PSTN {@code PhoneAccount}s are capable of placing emergency calls. 126 * <p> 127 * See {@link #getCapabilities} 128 */ 129 public static final int CAPABILITY_PLACE_EMERGENCY_CALLS = 0x10; 130 131 /** 132 * Flag indicating that this {@code PhoneAccount} is capable of being used by all users. This 133 * should only be used by system apps (and will be ignored for all other apps trying to use it). 134 * <p> 135 * See {@link #getCapabilities} 136 * @hide 137 */ 138 @SystemApi 139 public static final int CAPABILITY_MULTI_USER = 0x20; 140 141 /** 142 * Flag indicating that this {@code PhoneAccount} supports a subject for Calls. This means a 143 * caller is able to specify a short subject line for an outgoing call. A capable receiving 144 * device displays the call subject on the incoming call screen. 145 * <p> 146 * See {@link #getCapabilities} 147 */ 148 public static final int CAPABILITY_CALL_SUBJECT = 0x40; 149 150 /** 151 * Flag indicating that this {@code PhoneAccount} should only be used for emergency calls. 152 * <p> 153 * See {@link #getCapabilities} 154 * @hide 155 */ 156 public static final int CAPABILITY_EMERGENCY_CALLS_ONLY = 0x80; 157 158 /** 159 * Flag indicating that for this {@code PhoneAccount}, the ability to make a video call to a 160 * number relies on presence. Should only be set if the {@code PhoneAccount} also has 161 * {@link #CAPABILITY_VIDEO_CALLING}. 162 * <p> 163 * When set, the {@link ConnectionService} is responsible for toggling the 164 * {@link android.provider.ContactsContract.Data#CARRIER_PRESENCE_VT_CAPABLE} bit on the 165 * {@link android.provider.ContactsContract.Data#CARRIER_PRESENCE} column to indicate whether 166 * a contact's phone number supports video calling. 167 * <p> 168 * See {@link #getCapabilities} 169 */ 170 public static final int CAPABILITY_VIDEO_CALLING_RELIES_ON_PRESENCE = 0x100; 171 172 /** 173 * Flag indicating that for this {@link PhoneAccount}, emergency video calling is allowed. 174 * <p> 175 * When set, Telecom will allow emergency video calls to be placed. When not set, Telecom will 176 * convert all outgoing video calls to emergency numbers to audio-only. 177 * @hide 178 */ 179 public static final int CAPABILITY_EMERGENCY_VIDEO_CALLING = 0x200; 180 181 /** 182 * URI scheme for telephone number URIs. 183 */ 184 public static final String SCHEME_TEL = "tel"; 185 186 /** 187 * URI scheme for voicemail URIs. 188 */ 189 public static final String SCHEME_VOICEMAIL = "voicemail"; 190 191 /** 192 * URI scheme for SIP URIs. 193 */ 194 public static final String SCHEME_SIP = "sip"; 195 196 /** 197 * Indicating no icon tint is set. 198 * @hide 199 */ 200 public static final int NO_ICON_TINT = 0; 201 202 /** 203 * Indicating no hightlight color is set. 204 */ 205 public static final int NO_HIGHLIGHT_COLOR = 0; 206 207 /** 208 * Indicating no resource ID is set. 209 */ 210 public static final int NO_RESOURCE_ID = -1; 211 212 private final PhoneAccountHandle mAccountHandle; 213 private final Uri mAddress; 214 private final Uri mSubscriptionAddress; 215 private final int mCapabilities; 216 private final int mHighlightColor; 217 private final CharSequence mLabel; 218 private final CharSequence mShortDescription; 219 private final List<String> mSupportedUriSchemes; 220 private final Icon mIcon; 221 private final Bundle mExtras; 222 private boolean mIsEnabled; 223 224 /** 225 * Helper class for creating a {@link PhoneAccount}. 226 */ 227 public static class Builder { 228 private PhoneAccountHandle mAccountHandle; 229 private Uri mAddress; 230 private Uri mSubscriptionAddress; 231 private int mCapabilities; 232 private int mHighlightColor = NO_HIGHLIGHT_COLOR; 233 private CharSequence mLabel; 234 private CharSequence mShortDescription; 235 private List<String> mSupportedUriSchemes = new ArrayList<String>(); 236 private Icon mIcon; 237 private Bundle mExtras; 238 private boolean mIsEnabled = false; 239 240 /** 241 * Creates a builder with the specified {@link PhoneAccountHandle} and label. 242 */ 243 public Builder(PhoneAccountHandle accountHandle, CharSequence label) { 244 this.mAccountHandle = accountHandle; 245 this.mLabel = label; 246 } 247 248 /** 249 * Creates an instance of the {@link PhoneAccount.Builder} from an existing 250 * {@link PhoneAccount}. 251 * 252 * @param phoneAccount The {@link PhoneAccount} used to initialize the builder. 253 */ 254 public Builder(PhoneAccount phoneAccount) { 255 mAccountHandle = phoneAccount.getAccountHandle(); 256 mAddress = phoneAccount.getAddress(); 257 mSubscriptionAddress = phoneAccount.getSubscriptionAddress(); 258 mCapabilities = phoneAccount.getCapabilities(); 259 mHighlightColor = phoneAccount.getHighlightColor(); 260 mLabel = phoneAccount.getLabel(); 261 mShortDescription = phoneAccount.getShortDescription(); 262 mSupportedUriSchemes.addAll(phoneAccount.getSupportedUriSchemes()); 263 mIcon = phoneAccount.getIcon(); 264 mIsEnabled = phoneAccount.isEnabled(); 265 mExtras = phoneAccount.getExtras(); 266 } 267 268 /** 269 * Sets the address. See {@link PhoneAccount#getAddress}. 270 * 271 * @param value The address of the phone account. 272 * @return The builder. 273 */ 274 public Builder setAddress(Uri value) { 275 this.mAddress = value; 276 return this; 277 } 278 279 /** 280 * Sets the subscription address. See {@link PhoneAccount#getSubscriptionAddress}. 281 * 282 * @param value The subscription address. 283 * @return The builder. 284 */ 285 public Builder setSubscriptionAddress(Uri value) { 286 this.mSubscriptionAddress = value; 287 return this; 288 } 289 290 /** 291 * Sets the capabilities. See {@link PhoneAccount#getCapabilities}. 292 * 293 * @param value The capabilities to set. 294 * @return The builder. 295 */ 296 public Builder setCapabilities(int value) { 297 this.mCapabilities = value; 298 return this; 299 } 300 301 /** 302 * Sets the icon. See {@link PhoneAccount#getIcon}. 303 * 304 * @param icon The icon to set. 305 */ 306 public Builder setIcon(Icon icon) { 307 mIcon = icon; 308 return this; 309 } 310 311 /** 312 * Sets the highlight color. See {@link PhoneAccount#getHighlightColor}. 313 * 314 * @param value The highlight color. 315 * @return The builder. 316 */ 317 public Builder setHighlightColor(int value) { 318 this.mHighlightColor = value; 319 return this; 320 } 321 322 /** 323 * Sets the short description. See {@link PhoneAccount#getShortDescription}. 324 * 325 * @param value The short description. 326 * @return The builder. 327 */ 328 public Builder setShortDescription(CharSequence value) { 329 this.mShortDescription = value; 330 return this; 331 } 332 333 /** 334 * Specifies an additional URI scheme supported by the {@link PhoneAccount}. 335 * 336 * @param uriScheme The URI scheme. 337 * @return The builder. 338 */ 339 public Builder addSupportedUriScheme(String uriScheme) { 340 if (!TextUtils.isEmpty(uriScheme) && !mSupportedUriSchemes.contains(uriScheme)) { 341 this.mSupportedUriSchemes.add(uriScheme); 342 } 343 return this; 344 } 345 346 /** 347 * Specifies the URI schemes supported by the {@link PhoneAccount}. 348 * 349 * @param uriSchemes The URI schemes. 350 * @return The builder. 351 */ 352 public Builder setSupportedUriSchemes(List<String> uriSchemes) { 353 mSupportedUriSchemes.clear(); 354 355 if (uriSchemes != null && !uriSchemes.isEmpty()) { 356 for (String uriScheme : uriSchemes) { 357 addSupportedUriScheme(uriScheme); 358 } 359 } 360 return this; 361 } 362 363 /** 364 * Specifies the extras associated with the {@link PhoneAccount}. 365 * <p> 366 * {@code PhoneAccount}s only support extra values of type: {@link String}, {@link Integer}, 367 * and {@link Boolean}. Extras which are not of these types are ignored. 368 * 369 * @param extras 370 * @return 371 */ 372 public Builder setExtras(Bundle extras) { 373 mExtras = extras; 374 return this; 375 } 376 377 /** 378 * Sets the enabled state of the phone account. 379 * 380 * @param isEnabled The enabled state. 381 * @return The builder. 382 * @hide 383 */ 384 public Builder setIsEnabled(boolean isEnabled) { 385 mIsEnabled = isEnabled; 386 return this; 387 } 388 389 /** 390 * Creates an instance of a {@link PhoneAccount} based on the current builder settings. 391 * 392 * @return The {@link PhoneAccount}. 393 */ 394 public PhoneAccount build() { 395 // If no supported URI schemes were defined, assume "tel" is supported. 396 if (mSupportedUriSchemes.isEmpty()) { 397 addSupportedUriScheme(SCHEME_TEL); 398 } 399 400 return new PhoneAccount( 401 mAccountHandle, 402 mAddress, 403 mSubscriptionAddress, 404 mCapabilities, 405 mIcon, 406 mHighlightColor, 407 mLabel, 408 mShortDescription, 409 mSupportedUriSchemes, 410 mExtras, 411 mIsEnabled); 412 } 413 } 414 415 private PhoneAccount( 416 PhoneAccountHandle account, 417 Uri address, 418 Uri subscriptionAddress, 419 int capabilities, 420 Icon icon, 421 int highlightColor, 422 CharSequence label, 423 CharSequence shortDescription, 424 List<String> supportedUriSchemes, 425 Bundle extras, 426 boolean isEnabled) { 427 mAccountHandle = account; 428 mAddress = address; 429 mSubscriptionAddress = subscriptionAddress; 430 mCapabilities = capabilities; 431 mIcon = icon; 432 mHighlightColor = highlightColor; 433 mLabel = label; 434 mShortDescription = shortDescription; 435 mSupportedUriSchemes = Collections.unmodifiableList(supportedUriSchemes); 436 mExtras = extras; 437 mIsEnabled = isEnabled; 438 } 439 440 public static Builder builder( 441 PhoneAccountHandle accountHandle, 442 CharSequence label) { 443 return new Builder(accountHandle, label); 444 } 445 446 /** 447 * Returns a builder initialized with the current {@link PhoneAccount} instance. 448 * 449 * @return The builder. 450 */ 451 public Builder toBuilder() { return new Builder(this); } 452 453 /** 454 * The unique identifier of this {@code PhoneAccount}. 455 * 456 * @return A {@code PhoneAccountHandle}. 457 */ 458 public PhoneAccountHandle getAccountHandle() { 459 return mAccountHandle; 460 } 461 462 /** 463 * The address (e.g., a phone number) associated with this {@code PhoneAccount}. This 464 * represents the destination from which outgoing calls using this {@code PhoneAccount} 465 * will appear to come, if applicable, and the destination to which incoming calls using this 466 * {@code PhoneAccount} may be addressed. 467 * 468 * @return A address expressed as a {@code Uri}, for example, a phone number. 469 */ 470 public Uri getAddress() { 471 return mAddress; 472 } 473 474 /** 475 * The raw callback number used for this {@code PhoneAccount}, as distinct from 476 * {@link #getAddress()}. For the majority of {@code PhoneAccount}s this should be registered 477 * as {@code null}. It is used by the system for SIM-based {@code PhoneAccount} registration 478 * where {@link android.telephony.TelephonyManager#setLine1NumberForDisplay(String, String)} 479 * has been used to alter the callback number. 480 * <p> 481 * 482 * @return The subscription number, suitable for display to the user. 483 */ 484 public Uri getSubscriptionAddress() { 485 return mSubscriptionAddress; 486 } 487 488 /** 489 * The capabilities of this {@code PhoneAccount}. 490 * 491 * @return A bit field of flags describing this {@code PhoneAccount}'s capabilities. 492 */ 493 public int getCapabilities() { 494 return mCapabilities; 495 } 496 497 /** 498 * Determines if this {@code PhoneAccount} has a capabilities specified by the passed in 499 * bit mask. 500 * 501 * @param capability The capabilities to check. 502 * @return {@code true} if the phone account has the capability. 503 */ 504 public boolean hasCapabilities(int capability) { 505 return (mCapabilities & capability) == capability; 506 } 507 508 /** 509 * A short label describing a {@code PhoneAccount}. 510 * 511 * @return A label for this {@code PhoneAccount}. 512 */ 513 public CharSequence getLabel() { 514 return mLabel; 515 } 516 517 /** 518 * A short paragraph describing this {@code PhoneAccount}. 519 * 520 * @return A description for this {@code PhoneAccount}. 521 */ 522 public CharSequence getShortDescription() { 523 return mShortDescription; 524 } 525 526 /** 527 * The URI schemes supported by this {@code PhoneAccount}. 528 * 529 * @return The URI schemes. 530 */ 531 public List<String> getSupportedUriSchemes() { 532 return mSupportedUriSchemes; 533 } 534 535 /** 536 * The extras associated with this {@code PhoneAccount}. 537 * <p> 538 * A {@link ConnectionService} may provide implementation specific information about the 539 * {@link PhoneAccount} via the extras. 540 * 541 * @return The extras. 542 */ 543 public Bundle getExtras() { 544 return mExtras; 545 } 546 547 /** 548 * The icon to represent this {@code PhoneAccount}. 549 * 550 * @return The icon. 551 */ 552 public Icon getIcon() { 553 return mIcon; 554 } 555 556 /** 557 * Indicates whether the user has enabled this {@code PhoneAccount} or not. This value is only 558 * populated for {@code PhoneAccount}s returned by {@link TelecomManager#getPhoneAccount}. 559 * 560 * @return {@code true} if the account is enabled by the user, {@code false} otherwise. 561 */ 562 public boolean isEnabled() { 563 return mIsEnabled; 564 } 565 566 /** 567 * Determines if the {@link PhoneAccount} supports calls to/from addresses with a specified URI 568 * scheme. 569 * 570 * @param uriScheme The URI scheme to check. 571 * @return {@code true} if the {@code PhoneAccount} supports calls to/from addresses with the 572 * specified URI scheme. 573 */ 574 public boolean supportsUriScheme(String uriScheme) { 575 if (mSupportedUriSchemes == null || uriScheme == null) { 576 return false; 577 } 578 579 for (String scheme : mSupportedUriSchemes) { 580 if (scheme != null && scheme.equals(uriScheme)) { 581 return true; 582 } 583 } 584 return false; 585 } 586 587 /** 588 * A highlight color to use in displaying information about this {@code PhoneAccount}. 589 * 590 * @return A hexadecimal color value. 591 */ 592 public int getHighlightColor() { 593 return mHighlightColor; 594 } 595 596 /** 597 * Sets the enabled state of the phone account. 598 * @hide 599 */ 600 public void setIsEnabled(boolean isEnabled) { 601 mIsEnabled = isEnabled; 602 } 603 604 // 605 // Parcelable implementation 606 // 607 608 @Override 609 public int describeContents() { 610 return 0; 611 } 612 613 @Override 614 public void writeToParcel(Parcel out, int flags) { 615 if (mAccountHandle == null) { 616 out.writeInt(0); 617 } else { 618 out.writeInt(1); 619 mAccountHandle.writeToParcel(out, flags); 620 } 621 if (mAddress == null) { 622 out.writeInt(0); 623 } else { 624 out.writeInt(1); 625 mAddress.writeToParcel(out, flags); 626 } 627 if (mSubscriptionAddress == null) { 628 out.writeInt(0); 629 } else { 630 out.writeInt(1); 631 mSubscriptionAddress.writeToParcel(out, flags); 632 } 633 out.writeInt(mCapabilities); 634 out.writeInt(mHighlightColor); 635 out.writeCharSequence(mLabel); 636 out.writeCharSequence(mShortDescription); 637 out.writeStringList(mSupportedUriSchemes); 638 639 if (mIcon == null) { 640 out.writeInt(0); 641 } else { 642 out.writeInt(1); 643 mIcon.writeToParcel(out, flags); 644 } 645 out.writeByte((byte) (mIsEnabled ? 1 : 0)); 646 out.writeBundle(mExtras); 647 } 648 649 public static final Creator<PhoneAccount> CREATOR 650 = new Creator<PhoneAccount>() { 651 @Override 652 public PhoneAccount createFromParcel(Parcel in) { 653 return new PhoneAccount(in); 654 } 655 656 @Override 657 public PhoneAccount[] newArray(int size) { 658 return new PhoneAccount[size]; 659 } 660 }; 661 662 private PhoneAccount(Parcel in) { 663 if (in.readInt() > 0) { 664 mAccountHandle = PhoneAccountHandle.CREATOR.createFromParcel(in); 665 } else { 666 mAccountHandle = null; 667 } 668 if (in.readInt() > 0) { 669 mAddress = Uri.CREATOR.createFromParcel(in); 670 } else { 671 mAddress = null; 672 } 673 if (in.readInt() > 0) { 674 mSubscriptionAddress = Uri.CREATOR.createFromParcel(in); 675 } else { 676 mSubscriptionAddress = null; 677 } 678 mCapabilities = in.readInt(); 679 mHighlightColor = in.readInt(); 680 mLabel = in.readCharSequence(); 681 mShortDescription = in.readCharSequence(); 682 mSupportedUriSchemes = Collections.unmodifiableList(in.createStringArrayList()); 683 if (in.readInt() > 0) { 684 mIcon = Icon.CREATOR.createFromParcel(in); 685 } else { 686 mIcon = null; 687 } 688 mIsEnabled = in.readByte() == 1; 689 mExtras = in.readBundle(); 690 } 691 692 @Override 693 public String toString() { 694 StringBuilder sb = new StringBuilder().append("[[") 695 .append(mIsEnabled ? 'X' : ' ') 696 .append("] PhoneAccount: ") 697 .append(mAccountHandle) 698 .append(" Capabilities: ") 699 .append(capabilitiesToString(mCapabilities)) 700 .append(" Schemes: "); 701 for (String scheme : mSupportedUriSchemes) { 702 sb.append(scheme) 703 .append(" "); 704 } 705 sb.append(" Extras: "); 706 sb.append(mExtras); 707 sb.append("]"); 708 return sb.toString(); 709 } 710 711 /** 712 * Generates a string representation of a capabilities bitmask. 713 * 714 * @param capabilities The capabilities bitmask. 715 * @return String representation of the capabilities bitmask. 716 */ 717 private String capabilitiesToString(int capabilities) { 718 StringBuilder sb = new StringBuilder(); 719 if (hasCapabilities(CAPABILITY_VIDEO_CALLING)) { 720 sb.append("Video "); 721 } 722 if (hasCapabilities(CAPABILITY_VIDEO_CALLING_RELIES_ON_PRESENCE)) { 723 sb.append("Presence "); 724 } 725 if (hasCapabilities(CAPABILITY_CALL_PROVIDER)) { 726 sb.append("CallProvider "); 727 } 728 if (hasCapabilities(CAPABILITY_CALL_SUBJECT)) { 729 sb.append("CallSubject "); 730 } 731 if (hasCapabilities(CAPABILITY_CONNECTION_MANAGER)) { 732 sb.append("ConnectionMgr "); 733 } 734 if (hasCapabilities(CAPABILITY_EMERGENCY_CALLS_ONLY)) { 735 sb.append("EmergOnly "); 736 } 737 if (hasCapabilities(CAPABILITY_MULTI_USER)) { 738 sb.append("MultiUser "); 739 } 740 if (hasCapabilities(CAPABILITY_PLACE_EMERGENCY_CALLS)) { 741 sb.append("PlaceEmerg "); 742 } 743 if (hasCapabilities(CAPABILITY_EMERGENCY_VIDEO_CALLING)) { 744 sb.append("EmergVideo "); 745 } 746 if (hasCapabilities(CAPABILITY_SIM_SUBSCRIPTION)) { 747 sb.append("SimSub "); 748 } 749 return sb.toString(); 750 } 751 } 752
