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 17package android.telecom; 18 19import android.annotation.SdkConstant; 20import android.app.Service; 21import android.content.ComponentName; 22import android.content.Intent; 23import android.net.Uri; 24import android.os.Bundle; 25import android.os.Handler; 26import android.os.IBinder; 27import android.os.Looper; 28import android.os.Message; 29 30import com.android.internal.os.SomeArgs; 31import com.android.internal.telecom.IConnectionService; 32import com.android.internal.telecom.IConnectionServiceAdapter; 33import com.android.internal.telecom.RemoteServiceCallback; 34 35import java.util.ArrayList; 36import java.util.Collection; 37import java.util.Collections; 38import java.util.List; 39import java.util.Map; 40import java.util.UUID; 41import java.util.concurrent.ConcurrentHashMap; 42 43/** 44 * An abstract service that should be implemented by any apps which can make phone calls (VoIP or 45 * otherwise) and want those calls to be integrated into the built-in phone app. 46 * Once implemented, the {@code ConnectionService} needs two additional steps before it will be 47 * integrated into the phone app: 48 * <p> 49 * 1. <i>Registration in AndroidManifest.xml</i> 50 * <br/> 51 * <pre> 52 * <service android:name="com.example.package.MyConnectionService" 53 * android:label="@string/some_label_for_my_connection_service" 54 * android:permission="android.permission.BIND_TELECOM_CONNECTION_SERVICE"> 55 * <intent-filter> 56 * <action android:name="android.telecom.ConnectionService" /> 57 * </intent-filter> 58 * </service> 59 * </pre> 60 * <p> 61 * 2. <i> Registration of {@link PhoneAccount} with {@link TelecomManager}.</i> 62 * <br/> 63 * See {@link PhoneAccount} and {@link TelecomManager#registerPhoneAccount} for more information. 64 * <p> 65 * Once registered and enabled by the user in the phone app settings, telecom will bind to a 66 * {@code ConnectionService} implementation when it wants that {@code ConnectionService} to place 67 * a call or the service has indicated that is has an incoming call through 68 * {@link TelecomManager#addNewIncomingCall}. The {@code ConnectionService} can then expect a call 69 * to {@link #onCreateIncomingConnection} or {@link #onCreateOutgoingConnection} wherein it 70 * should provide a new instance of a {@link Connection} object. It is through this 71 * {@link Connection} object that telecom receives state updates and the {@code ConnectionService} 72 * receives call-commands such as answer, reject, hold and disconnect. 73 * <p> 74 * When there are no more live calls, telecom will unbind from the {@code ConnectionService}. 75 */ 76public abstract class ConnectionService extends Service { 77 /** 78 * The {@link Intent} that must be declared as handled by the service. 79 */ 80 @SdkConstant(SdkConstant.SdkConstantType.SERVICE_ACTION) 81 public static final String SERVICE_INTERFACE = "android.telecom.ConnectionService"; 82 83 // Flag controlling whether PII is emitted into the logs 84 private static final boolean PII_DEBUG = Log.isLoggable(android.util.Log.DEBUG); 85 86 private static final int MSG_ADD_CONNECTION_SERVICE_ADAPTER = 1; 87 private static final int MSG_CREATE_CONNECTION = 2; 88 private static final int MSG_ABORT = 3; 89 private static final int MSG_ANSWER = 4; 90 private static final int MSG_REJECT = 5; 91 private static final int MSG_DISCONNECT = 6; 92 private static final int MSG_HOLD = 7; 93 private static final int MSG_UNHOLD = 8; 94 private static final int MSG_ON_CALL_AUDIO_STATE_CHANGED = 9; 95 private static final int MSG_PLAY_DTMF_TONE = 10; 96 private static final int MSG_STOP_DTMF_TONE = 11; 97 private static final int MSG_CONFERENCE = 12; 98 private static final int MSG_SPLIT_FROM_CONFERENCE = 13; 99 private static final int MSG_ON_POST_DIAL_CONTINUE = 14; 100 private static final int MSG_REMOVE_CONNECTION_SERVICE_ADAPTER = 16; 101 private static final int MSG_ANSWER_VIDEO = 17; 102 private static final int MSG_MERGE_CONFERENCE = 18; 103 private static final int MSG_SWAP_CONFERENCE = 19; 104 private static final int MSG_REJECT_WITH_MESSAGE = 20; 105 private static final int MSG_SILENCE = 21; 106 private static final int MSG_PULL_EXTERNAL_CALL = 22; 107 private static final int MSG_SEND_CALL_EVENT = 23; 108 private static final int MSG_ON_EXTRAS_CHANGED = 24; 109 110 private static Connection sNullConnection; 111 112 private final Map<String, Connection> mConnectionById = new ConcurrentHashMap<>(); 113 private final Map<Connection, String> mIdByConnection = new ConcurrentHashMap<>(); 114 private final Map<String, Conference> mConferenceById = new ConcurrentHashMap<>(); 115 private final Map<Conference, String> mIdByConference = new ConcurrentHashMap<>(); 116 private final RemoteConnectionManager mRemoteConnectionManager = 117 new RemoteConnectionManager(this); 118 private final List<Runnable> mPreInitializationConnectionRequests = new ArrayList<>(); 119 private final ConnectionServiceAdapter mAdapter = new ConnectionServiceAdapter(); 120 121 private boolean mAreAccountsInitialized = false; 122 private Conference sNullConference; 123 private Object mIdSyncRoot = new Object(); 124 private int mId = 0; 125 126 private final IBinder mBinder = new IConnectionService.Stub() { 127 @Override 128 public void addConnectionServiceAdapter(IConnectionServiceAdapter adapter) { 129 mHandler.obtainMessage(MSG_ADD_CONNECTION_SERVICE_ADAPTER, adapter).sendToTarget(); 130 } 131 132 public void removeConnectionServiceAdapter(IConnectionServiceAdapter adapter) { 133 mHandler.obtainMessage(MSG_REMOVE_CONNECTION_SERVICE_ADAPTER, adapter).sendToTarget(); 134 } 135 136 @Override 137 public void createConnection( 138 PhoneAccountHandle connectionManagerPhoneAccount, 139 String id, 140 ConnectionRequest request, 141 boolean isIncoming, 142 boolean isUnknown) { 143 SomeArgs args = SomeArgs.obtain(); 144 args.arg1 = connectionManagerPhoneAccount; 145 args.arg2 = id; 146 args.arg3 = request; 147 args.argi1 = isIncoming ? 1 : 0; 148 args.argi2 = isUnknown ? 1 : 0; 149 mHandler.obtainMessage(MSG_CREATE_CONNECTION, args).sendToTarget(); 150 } 151 152 @Override 153 public void abort(String callId) { 154 mHandler.obtainMessage(MSG_ABORT, callId).sendToTarget(); 155 } 156 157 @Override 158 public void answerVideo(String callId, int videoState) { 159 SomeArgs args = SomeArgs.obtain(); 160 args.arg1 = callId; 161 args.argi1 = videoState; 162 mHandler.obtainMessage(MSG_ANSWER_VIDEO, args).sendToTarget(); 163 } 164 165 @Override 166 public void answer(String callId) { 167 mHandler.obtainMessage(MSG_ANSWER, callId).sendToTarget(); 168 } 169 170 @Override 171 public void reject(String callId) { 172 mHandler.obtainMessage(MSG_REJECT, callId).sendToTarget(); 173 } 174 175 @Override 176 public void rejectWithMessage(String callId, String message) { 177 SomeArgs args = SomeArgs.obtain(); 178 args.arg1 = callId; 179 args.arg2 = message; 180 mHandler.obtainMessage(MSG_REJECT_WITH_MESSAGE, args).sendToTarget(); 181 } 182 183 @Override 184 public void silence(String callId) { 185 mHandler.obtainMessage(MSG_SILENCE, callId).sendToTarget(); 186 } 187 188 @Override 189 public void disconnect(String callId) { 190 mHandler.obtainMessage(MSG_DISCONNECT, callId).sendToTarget(); 191 } 192 193 @Override 194 public void hold(String callId) { 195 mHandler.obtainMessage(MSG_HOLD, callId).sendToTarget(); 196 } 197 198 @Override 199 public void unhold(String callId) { 200 mHandler.obtainMessage(MSG_UNHOLD, callId).sendToTarget(); 201 } 202 203 @Override 204 public void onCallAudioStateChanged(String callId, CallAudioState callAudioState) { 205 SomeArgs args = SomeArgs.obtain(); 206 args.arg1 = callId; 207 args.arg2 = callAudioState; 208 mHandler.obtainMessage(MSG_ON_CALL_AUDIO_STATE_CHANGED, args).sendToTarget(); 209 } 210 211 @Override 212 public void playDtmfTone(String callId, char digit) { 213 mHandler.obtainMessage(MSG_PLAY_DTMF_TONE, digit, 0, callId).sendToTarget(); 214 } 215 216 @Override 217 public void stopDtmfTone(String callId) { 218 mHandler.obtainMessage(MSG_STOP_DTMF_TONE, callId).sendToTarget(); 219 } 220 221 @Override 222 public void conference(String callId1, String callId2) { 223 SomeArgs args = SomeArgs.obtain(); 224 args.arg1 = callId1; 225 args.arg2 = callId2; 226 mHandler.obtainMessage(MSG_CONFERENCE, args).sendToTarget(); 227 } 228 229 @Override 230 public void splitFromConference(String callId) { 231 mHandler.obtainMessage(MSG_SPLIT_FROM_CONFERENCE, callId).sendToTarget(); 232 } 233 234 @Override 235 public void mergeConference(String callId) { 236 mHandler.obtainMessage(MSG_MERGE_CONFERENCE, callId).sendToTarget(); 237 } 238 239 @Override 240 public void swapConference(String callId) { 241 mHandler.obtainMessage(MSG_SWAP_CONFERENCE, callId).sendToTarget(); 242 } 243 244 @Override 245 public void onPostDialContinue(String callId, boolean proceed) { 246 SomeArgs args = SomeArgs.obtain(); 247 args.arg1 = callId; 248 args.argi1 = proceed ? 1 : 0; 249 mHandler.obtainMessage(MSG_ON_POST_DIAL_CONTINUE, args).sendToTarget(); 250 } 251 252 @Override 253 public void pullExternalCall(String callId) { 254 mHandler.obtainMessage(MSG_PULL_EXTERNAL_CALL, callId).sendToTarget(); 255 } 256 257 @Override 258 public void sendCallEvent(String callId, String event, Bundle extras) { 259 SomeArgs args = SomeArgs.obtain(); 260 args.arg1 = callId; 261 args.arg2 = event; 262 args.arg3 = extras; 263 mHandler.obtainMessage(MSG_SEND_CALL_EVENT, args).sendToTarget(); 264 } 265 266 @Override 267 public void onExtrasChanged(String callId, Bundle extras) { 268 SomeArgs args = SomeArgs.obtain(); 269 args.arg1 = callId; 270 args.arg2 = extras; 271 mHandler.obtainMessage(MSG_ON_EXTRAS_CHANGED, args).sendToTarget(); 272 } 273 }; 274 275 private final Handler mHandler = new Handler(Looper.getMainLooper()) { 276 @Override 277 public void handleMessage(Message msg) { 278 switch (msg.what) { 279 case MSG_ADD_CONNECTION_SERVICE_ADAPTER: 280 mAdapter.addAdapter((IConnectionServiceAdapter) msg.obj); 281 onAdapterAttached(); 282 break; 283 case MSG_REMOVE_CONNECTION_SERVICE_ADAPTER: 284 mAdapter.removeAdapter((IConnectionServiceAdapter) msg.obj); 285 break; 286 case MSG_CREATE_CONNECTION: { 287 SomeArgs args = (SomeArgs) msg.obj; 288 try { 289 final PhoneAccountHandle connectionManagerPhoneAccount = 290 (PhoneAccountHandle) args.arg1; 291 final String id = (String) args.arg2; 292 final ConnectionRequest request = (ConnectionRequest) args.arg3; 293 final boolean isIncoming = args.argi1 == 1; 294 final boolean isUnknown = args.argi2 == 1; 295 if (!mAreAccountsInitialized) { 296 Log.d(this, "Enqueueing pre-init request %s", id); 297 mPreInitializationConnectionRequests.add(new Runnable() { 298 @Override 299 public void run() { 300 createConnection( 301 connectionManagerPhoneAccount, 302 id, 303 request, 304 isIncoming, 305 isUnknown); 306 } 307 }); 308 } else { 309 createConnection( 310 connectionManagerPhoneAccount, 311 id, 312 request, 313 isIncoming, 314 isUnknown); 315 } 316 } finally { 317 args.recycle(); 318 } 319 break; 320 } 321 case MSG_ABORT: 322 abort((String) msg.obj); 323 break; 324 case MSG_ANSWER: 325 answer((String) msg.obj); 326 break; 327 case MSG_ANSWER_VIDEO: { 328 SomeArgs args = (SomeArgs) msg.obj; 329 try { 330 String callId = (String) args.arg1; 331 int videoState = args.argi1; 332 answerVideo(callId, videoState); 333 } finally { 334 args.recycle(); 335 } 336 break; 337 } 338 case MSG_REJECT: 339 reject((String) msg.obj); 340 break; 341 case MSG_REJECT_WITH_MESSAGE: { 342 SomeArgs args = (SomeArgs) msg.obj; 343 try { 344 reject((String) args.arg1, (String) args.arg2); 345 } finally { 346 args.recycle(); 347 } 348 break; 349 } 350 case MSG_DISCONNECT: 351 disconnect((String) msg.obj); 352 break; 353 case MSG_SILENCE: 354 silence((String) msg.obj); 355 break; 356 case MSG_HOLD: 357 hold((String) msg.obj); 358 break; 359 case MSG_UNHOLD: 360 unhold((String) msg.obj); 361 break; 362 case MSG_ON_CALL_AUDIO_STATE_CHANGED: { 363 SomeArgs args = (SomeArgs) msg.obj; 364 try { 365 String callId = (String) args.arg1; 366 CallAudioState audioState = (CallAudioState) args.arg2; 367 onCallAudioStateChanged(callId, new CallAudioState(audioState)); 368 } finally { 369 args.recycle(); 370 } 371 break; 372 } 373 case MSG_PLAY_DTMF_TONE: 374 playDtmfTone((String) msg.obj, (char) msg.arg1); 375 break; 376 case MSG_STOP_DTMF_TONE: 377 stopDtmfTone((String) msg.obj); 378 break; 379 case MSG_CONFERENCE: { 380 SomeArgs args = (SomeArgs) msg.obj; 381 try { 382 String callId1 = (String) args.arg1; 383 String callId2 = (String) args.arg2; 384 conference(callId1, callId2); 385 } finally { 386 args.recycle(); 387 } 388 break; 389 } 390 case MSG_SPLIT_FROM_CONFERENCE: 391 splitFromConference((String) msg.obj); 392 break; 393 case MSG_MERGE_CONFERENCE: 394 mergeConference((String) msg.obj); 395 break; 396 case MSG_SWAP_CONFERENCE: 397 swapConference((String) msg.obj); 398 break; 399 case MSG_ON_POST_DIAL_CONTINUE: { 400 SomeArgs args = (SomeArgs) msg.obj; 401 try { 402 String callId = (String) args.arg1; 403 boolean proceed = (args.argi1 == 1); 404 onPostDialContinue(callId, proceed); 405 } finally { 406 args.recycle(); 407 } 408 break; 409 } 410 case MSG_PULL_EXTERNAL_CALL: { 411 pullExternalCall((String) msg.obj); 412 break; 413 } 414 case MSG_SEND_CALL_EVENT: { 415 SomeArgs args = (SomeArgs) msg.obj; 416 try { 417 String callId = (String) args.arg1; 418 String event = (String) args.arg2; 419 Bundle extras = (Bundle) args.arg3; 420 sendCallEvent(callId, event, extras); 421 } finally { 422 args.recycle(); 423 } 424 break; 425 } 426 case MSG_ON_EXTRAS_CHANGED: { 427 SomeArgs args = (SomeArgs) msg.obj; 428 try { 429 String callId = (String) args.arg1; 430 Bundle extras = (Bundle) args.arg2; 431 handleExtrasChanged(callId, extras); 432 } finally { 433 args.recycle(); 434 } 435 break; 436 } 437 default: 438 break; 439 } 440 } 441 }; 442 443 private final Conference.Listener mConferenceListener = new Conference.Listener() { 444 @Override 445 public void onStateChanged(Conference conference, int oldState, int newState) { 446 String id = mIdByConference.get(conference); 447 switch (newState) { 448 case Connection.STATE_ACTIVE: 449 mAdapter.setActive(id); 450 break; 451 case Connection.STATE_HOLDING: 452 mAdapter.setOnHold(id); 453 break; 454 case Connection.STATE_DISCONNECTED: 455 // handled by onDisconnected 456 break; 457 } 458 } 459 460 @Override 461 public void onDisconnected(Conference conference, DisconnectCause disconnectCause) { 462 String id = mIdByConference.get(conference); 463 mAdapter.setDisconnected(id, disconnectCause); 464 } 465 466 @Override 467 public void onConnectionAdded(Conference conference, Connection connection) { 468 } 469 470 @Override 471 public void onConnectionRemoved(Conference conference, Connection connection) { 472 } 473 474 @Override 475 public void onConferenceableConnectionsChanged( 476 Conference conference, List<Connection> conferenceableConnections) { 477 mAdapter.setConferenceableConnections( 478 mIdByConference.get(conference), 479 createConnectionIdList(conferenceableConnections)); 480 } 481 482 @Override 483 public void onDestroyed(Conference conference) { 484 removeConference(conference); 485 } 486 487 @Override 488 public void onConnectionCapabilitiesChanged( 489 Conference conference, 490 int connectionCapabilities) { 491 String id = mIdByConference.get(conference); 492 Log.d(this, "call capabilities: conference: %s", 493 Connection.capabilitiesToString(connectionCapabilities)); 494 mAdapter.setConnectionCapabilities(id, connectionCapabilities); 495 } 496 497 @Override 498 public void onConnectionPropertiesChanged( 499 Conference conference, 500 int connectionProperties) { 501 String id = mIdByConference.get(conference); 502 Log.d(this, "call capabilities: conference: %s", 503 Connection.propertiesToString(connectionProperties)); 504 mAdapter.setConnectionProperties(id, connectionProperties); 505 } 506 507 @Override 508 public void onVideoStateChanged(Conference c, int videoState) { 509 String id = mIdByConference.get(c); 510 Log.d(this, "onVideoStateChanged set video state %d", videoState); 511 mAdapter.setVideoState(id, videoState); 512 } 513 514 @Override 515 public void onVideoProviderChanged(Conference c, Connection.VideoProvider videoProvider) { 516 String id = mIdByConference.get(c); 517 Log.d(this, "onVideoProviderChanged: Connection: %s, VideoProvider: %s", c, 518 videoProvider); 519 mAdapter.setVideoProvider(id, videoProvider); 520 } 521 522 @Override 523 public void onStatusHintsChanged(Conference conference, StatusHints statusHints) { 524 String id = mIdByConference.get(conference); 525 if (id != null) { 526 mAdapter.setStatusHints(id, statusHints); 527 } 528 } 529 530 @Override 531 public void onExtrasChanged(Conference c, Bundle extras) { 532 String id = mIdByConference.get(c); 533 if (id != null) { 534 mAdapter.putExtras(id, extras); 535 } 536 } 537 538 @Override 539 public void onExtrasRemoved(Conference c, List<String> keys) { 540 String id = mIdByConference.get(c); 541 if (id != null) { 542 mAdapter.removeExtras(id, keys); 543 } 544 } 545 }; 546 547 private final Connection.Listener mConnectionListener = new Connection.Listener() { 548 @Override 549 public void onStateChanged(Connection c, int state) { 550 String id = mIdByConnection.get(c); 551 Log.d(this, "Adapter set state %s %s", id, Connection.stateToString(state)); 552 switch (state) { 553 case Connection.STATE_ACTIVE: 554 mAdapter.setActive(id); 555 break; 556 case Connection.STATE_DIALING: 557 mAdapter.setDialing(id); 558 break; 559 case Connection.STATE_PULLING_CALL: 560 mAdapter.setPulling(id); 561 break; 562 case Connection.STATE_DISCONNECTED: 563 // Handled in onDisconnected() 564 break; 565 case Connection.STATE_HOLDING: 566 mAdapter.setOnHold(id); 567 break; 568 case Connection.STATE_NEW: 569 // Nothing to tell Telecom 570 break; 571 case Connection.STATE_RINGING: 572 mAdapter.setRinging(id); 573 break; 574 } 575 } 576 577 @Override 578 public void onDisconnected(Connection c, DisconnectCause disconnectCause) { 579 String id = mIdByConnection.get(c); 580 Log.d(this, "Adapter set disconnected %s", disconnectCause); 581 mAdapter.setDisconnected(id, disconnectCause); 582 } 583 584 @Override 585 public void onVideoStateChanged(Connection c, int videoState) { 586 String id = mIdByConnection.get(c); 587 Log.d(this, "Adapter set video state %d", videoState); 588 mAdapter.setVideoState(id, videoState); 589 } 590 591 @Override 592 public void onAddressChanged(Connection c, Uri address, int presentation) { 593 String id = mIdByConnection.get(c); 594 mAdapter.setAddress(id, address, presentation); 595 } 596 597 @Override 598 public void onCallerDisplayNameChanged( 599 Connection c, String callerDisplayName, int presentation) { 600 String id = mIdByConnection.get(c); 601 mAdapter.setCallerDisplayName(id, callerDisplayName, presentation); 602 } 603 604 @Override 605 public void onDestroyed(Connection c) { 606 removeConnection(c); 607 } 608 609 @Override 610 public void onPostDialWait(Connection c, String remaining) { 611 String id = mIdByConnection.get(c); 612 Log.d(this, "Adapter onPostDialWait %s, %s", c, remaining); 613 mAdapter.onPostDialWait(id, remaining); 614 } 615 616 @Override 617 public void onPostDialChar(Connection c, char nextChar) { 618 String id = mIdByConnection.get(c); 619 Log.d(this, "Adapter onPostDialChar %s, %s", c, nextChar); 620 mAdapter.onPostDialChar(id, nextChar); 621 } 622 623 @Override 624 public void onRingbackRequested(Connection c, boolean ringback) { 625 String id = mIdByConnection.get(c); 626 Log.d(this, "Adapter onRingback %b", ringback); 627 mAdapter.setRingbackRequested(id, ringback); 628 } 629 630 @Override 631 public void onConnectionCapabilitiesChanged(Connection c, int capabilities) { 632 String id = mIdByConnection.get(c); 633 Log.d(this, "capabilities: parcelableconnection: %s", 634 Connection.capabilitiesToString(capabilities)); 635 mAdapter.setConnectionCapabilities(id, capabilities); 636 } 637 638 @Override 639 public void onConnectionPropertiesChanged(Connection c, int properties) { 640 String id = mIdByConnection.get(c); 641 Log.d(this, "properties: parcelableconnection: %s", 642 Connection.propertiesToString(properties)); 643 mAdapter.setConnectionProperties(id, properties); 644 } 645 646 @Override 647 public void onVideoProviderChanged(Connection c, Connection.VideoProvider videoProvider) { 648 String id = mIdByConnection.get(c); 649 Log.d(this, "onVideoProviderChanged: Connection: %s, VideoProvider: %s", c, 650 videoProvider); 651 mAdapter.setVideoProvider(id, videoProvider); 652 } 653 654 @Override 655 public void onAudioModeIsVoipChanged(Connection c, boolean isVoip) { 656 String id = mIdByConnection.get(c); 657 mAdapter.setIsVoipAudioMode(id, isVoip); 658 } 659 660 @Override 661 public void onStatusHintsChanged(Connection c, StatusHints statusHints) { 662 String id = mIdByConnection.get(c); 663 mAdapter.setStatusHints(id, statusHints); 664 } 665 666 @Override 667 public void onConferenceablesChanged( 668 Connection connection, List<Conferenceable> conferenceables) { 669 mAdapter.setConferenceableConnections( 670 mIdByConnection.get(connection), 671 createIdList(conferenceables)); 672 } 673 674 @Override 675 public void onConferenceChanged(Connection connection, Conference conference) { 676 String id = mIdByConnection.get(connection); 677 if (id != null) { 678 String conferenceId = null; 679 if (conference != null) { 680 conferenceId = mIdByConference.get(conference); 681 } 682 mAdapter.setIsConferenced(id, conferenceId); 683 } 684 } 685 686 @Override 687 public void onConferenceMergeFailed(Connection connection) { 688 String id = mIdByConnection.get(connection); 689 if (id != null) { 690 mAdapter.onConferenceMergeFailed(id); 691 } 692 } 693 694 @Override 695 public void onExtrasChanged(Connection c, Bundle extras) { 696 String id = mIdByConnection.get(c); 697 if (id != null) { 698 mAdapter.putExtras(id, extras); 699 } 700 } 701 702 public void onExtrasRemoved(Connection c, List<String> keys) { 703 String id = mIdByConnection.get(c); 704 if (id != null) { 705 mAdapter.removeExtras(id, keys); 706 } 707 } 708 709 710 @Override 711 public void onConnectionEvent(Connection connection, String event, Bundle extras) { 712 String id = mIdByConnection.get(connection); 713 if (id != null) { 714 mAdapter.onConnectionEvent(id, event, extras); 715 } 716 } 717 }; 718 719 /** {@inheritDoc} */ 720 @Override 721 public final IBinder onBind(Intent intent) { 722 return mBinder; 723 } 724 725 /** {@inheritDoc} */ 726 @Override 727 public boolean onUnbind(Intent intent) { 728 endAllConnections(); 729 return super.onUnbind(intent); 730 } 731 732 /** 733 * This can be used by telecom to either create a new outgoing call or attach to an existing 734 * incoming call. In either case, telecom will cycle through a set of services and call 735 * createConnection util a connection service cancels the process or completes it successfully. 736 */ 737 private void createConnection( 738 final PhoneAccountHandle callManagerAccount, 739 final String callId, 740 final ConnectionRequest request, 741 boolean isIncoming, 742 boolean isUnknown) { 743 Log.d(this, "createConnection, callManagerAccount: %s, callId: %s, request: %s, " + 744 "isIncoming: %b, isUnknown: %b", callManagerAccount, callId, request, 745 isIncoming, 746 isUnknown); 747 748 Connection connection = isUnknown ? onCreateUnknownConnection(callManagerAccount, request) 749 : isIncoming ? onCreateIncomingConnection(callManagerAccount, request) 750 : onCreateOutgoingConnection(callManagerAccount, request); 751 Log.d(this, "createConnection, connection: %s", connection); 752 if (connection == null) { 753 connection = Connection.createFailedConnection( 754 new DisconnectCause(DisconnectCause.ERROR)); 755 } 756 757 connection.setTelecomCallId(callId); 758 if (connection.getState() != Connection.STATE_DISCONNECTED) { 759 addConnection(callId, connection); 760 } 761 762 Uri address = connection.getAddress(); 763 String number = address == null ? "null" : address.getSchemeSpecificPart(); 764 Log.v(this, "createConnection, number: %s, state: %s, capabilities: %s, properties: %s", 765 Connection.toLogSafePhoneNumber(number), 766 Connection.stateToString(connection.getState()), 767 Connection.capabilitiesToString(connection.getConnectionCapabilities()), 768 Connection.propertiesToString(connection.getConnectionProperties())); 769 770 Log.d(this, "createConnection, calling handleCreateConnectionSuccessful %s", callId); 771 mAdapter.handleCreateConnectionComplete( 772 callId, 773 request, 774 new ParcelableConnection( 775 request.getAccountHandle(), 776 connection.getState(), 777 connection.getConnectionCapabilities(), 778 connection.getConnectionProperties(), 779 connection.getSupportedAudioRoutes(), 780 connection.getAddress(), 781 connection.getAddressPresentation(), 782 connection.getCallerDisplayName(), 783 connection.getCallerDisplayNamePresentation(), 784 connection.getVideoProvider() == null ? 785 null : connection.getVideoProvider().getInterface(), 786 connection.getVideoState(), 787 connection.isRingbackRequested(), 788 connection.getAudioModeIsVoip(), 789 connection.getConnectTimeMillis(), 790 connection.getStatusHints(), 791 connection.getDisconnectCause(), 792 createIdList(connection.getConferenceables()), 793 connection.getExtras())); 794 if (isUnknown) { 795 triggerConferenceRecalculate(); 796 } 797 } 798 799 private void abort(String callId) { 800 Log.d(this, "abort %s", callId); 801 findConnectionForAction(callId, "abort").onAbort(); 802 } 803 804 private void answerVideo(String callId, int videoState) { 805 Log.d(this, "answerVideo %s", callId); 806 findConnectionForAction(callId, "answer").onAnswer(videoState); 807 } 808 809 private void answer(String callId) { 810 Log.d(this, "answer %s", callId); 811 findConnectionForAction(callId, "answer").onAnswer(); 812 } 813 814 private void reject(String callId) { 815 Log.d(this, "reject %s", callId); 816 findConnectionForAction(callId, "reject").onReject(); 817 } 818 819 private void reject(String callId, String rejectWithMessage) { 820 Log.d(this, "reject %s with message", callId); 821 findConnectionForAction(callId, "reject").onReject(rejectWithMessage); 822 } 823 824 private void silence(String callId) { 825 Log.d(this, "silence %s", callId); 826 findConnectionForAction(callId, "silence").onSilence(); 827 } 828 829 private void disconnect(String callId) { 830 Log.d(this, "disconnect %s", callId); 831 if (mConnectionById.containsKey(callId)) { 832 findConnectionForAction(callId, "disconnect").onDisconnect(); 833 } else { 834 findConferenceForAction(callId, "disconnect").onDisconnect(); 835 } 836 } 837 838 private void hold(String callId) { 839 Log.d(this, "hold %s", callId); 840 if (mConnectionById.containsKey(callId)) { 841 findConnectionForAction(callId, "hold").onHold(); 842 } else { 843 findConferenceForAction(callId, "hold").onHold(); 844 } 845 } 846 847 private void unhold(String callId) { 848 Log.d(this, "unhold %s", callId); 849 if (mConnectionById.containsKey(callId)) { 850 findConnectionForAction(callId, "unhold").onUnhold(); 851 } else { 852 findConferenceForAction(callId, "unhold").onUnhold(); 853 } 854 } 855 856 private void onCallAudioStateChanged(String callId, CallAudioState callAudioState) { 857 Log.d(this, "onAudioStateChanged %s %s", callId, callAudioState); 858 if (mConnectionById.containsKey(callId)) { 859 findConnectionForAction(callId, "onCallAudioStateChanged").setCallAudioState( 860 callAudioState); 861 } else { 862 findConferenceForAction(callId, "onCallAudioStateChanged").setCallAudioState( 863 callAudioState); 864 } 865 } 866 867 private void playDtmfTone(String callId, char digit) { 868 Log.d(this, "playDtmfTone %s %c", callId, digit); 869 if (mConnectionById.containsKey(callId)) { 870 findConnectionForAction(callId, "playDtmfTone").onPlayDtmfTone(digit); 871 } else { 872 findConferenceForAction(callId, "playDtmfTone").onPlayDtmfTone(digit); 873 } 874 } 875 876 private void stopDtmfTone(String callId) { 877 Log.d(this, "stopDtmfTone %s", callId); 878 if (mConnectionById.containsKey(callId)) { 879 findConnectionForAction(callId, "stopDtmfTone").onStopDtmfTone(); 880 } else { 881 findConferenceForAction(callId, "stopDtmfTone").onStopDtmfTone(); 882 } 883 } 884 885 private void conference(String callId1, String callId2) { 886 Log.d(this, "conference %s, %s", callId1, callId2); 887 888 // Attempt to get second connection or conference. 889 Connection connection2 = findConnectionForAction(callId2, "conference"); 890 Conference conference2 = getNullConference(); 891 if (connection2 == getNullConnection()) { 892 conference2 = findConferenceForAction(callId2, "conference"); 893 if (conference2 == getNullConference()) { 894 Log.w(this, "Connection2 or Conference2 missing in conference request %s.", 895 callId2); 896 return; 897 } 898 } 899 900 // Attempt to get first connection or conference and perform merge. 901 Connection connection1 = findConnectionForAction(callId1, "conference"); 902 if (connection1 == getNullConnection()) { 903 Conference conference1 = findConferenceForAction(callId1, "addConnection"); 904 if (conference1 == getNullConference()) { 905 Log.w(this, 906 "Connection1 or Conference1 missing in conference request %s.", 907 callId1); 908 } else { 909 // Call 1 is a conference. 910 if (connection2 != getNullConnection()) { 911 // Call 2 is a connection so merge via call 1 (conference). 912 conference1.onMerge(connection2); 913 } else { 914 // Call 2 is ALSO a conference; this should never happen. 915 Log.wtf(this, "There can only be one conference and an attempt was made to " + 916 "merge two conferences."); 917 return; 918 } 919 } 920 } else { 921 // Call 1 is a connection. 922 if (conference2 != getNullConference()) { 923 // Call 2 is a conference, so merge via call 2. 924 conference2.onMerge(connection1); 925 } else { 926 // Call 2 is a connection, so merge together. 927 onConference(connection1, connection2); 928 } 929 } 930 } 931 932 private void splitFromConference(String callId) { 933 Log.d(this, "splitFromConference(%s)", callId); 934 935 Connection connection = findConnectionForAction(callId, "splitFromConference"); 936 if (connection == getNullConnection()) { 937 Log.w(this, "Connection missing in conference request %s.", callId); 938 return; 939 } 940 941 Conference conference = connection.getConference(); 942 if (conference != null) { 943 conference.onSeparate(connection); 944 } 945 } 946 947 private void mergeConference(String callId) { 948 Log.d(this, "mergeConference(%s)", callId); 949 Conference conference = findConferenceForAction(callId, "mergeConference"); 950 if (conference != null) { 951 conference.onMerge(); 952 } 953 } 954 955 private void swapConference(String callId) { 956 Log.d(this, "swapConference(%s)", callId); 957 Conference conference = findConferenceForAction(callId, "swapConference"); 958 if (conference != null) { 959 conference.onSwap(); 960 } 961 } 962 963 /** 964 * Notifies a {@link Connection} of a request to pull an external call. 965 * 966 * See {@link Call#pullExternalCall()}. 967 * 968 * @param callId The ID of the call to pull. 969 */ 970 private void pullExternalCall(String callId) { 971 Log.d(this, "pullExternalCall(%s)", callId); 972 Connection connection = findConnectionForAction(callId, "pullExternalCall"); 973 if (connection != null) { 974 connection.onPullExternalCall(); 975 } 976 } 977 978 /** 979 * Notifies a {@link Connection} of a call event. 980 * 981 * See {@link Call#sendCallEvent(String, Bundle)}. 982 * 983 * @param callId The ID of the call receiving the event. 984 * @param event The event. 985 * @param extras Extras associated with the event. 986 */ 987 private void sendCallEvent(String callId, String event, Bundle extras) { 988 Log.d(this, "sendCallEvent(%s, %s)", callId, event); 989 Connection connection = findConnectionForAction(callId, "sendCallEvent"); 990 if (connection != null) { 991 connection.onCallEvent(event, extras); 992 } 993 994 } 995 996 /** 997 * Notifies a {@link Connection} or {@link Conference} of a change to the extras from Telecom. 998 * <p> 999 * These extra changes can originate from Telecom itself, or from an {@link InCallService} via 1000 * the {@link android.telecom.Call#putExtra(String, boolean)}, 1001 * {@link android.telecom.Call#putExtra(String, int)}, 1002 * {@link android.telecom.Call#putExtra(String, String)}, 1003 * {@link Call#removeExtras(List)}. 1004 * 1005 * @param callId The ID of the call receiving the event. 1006 * @param extras The new extras bundle. 1007 */ 1008 private void handleExtrasChanged(String callId, Bundle extras) { 1009 Log.d(this, "handleExtrasChanged(%s, %s)", callId, extras); 1010 if (mConnectionById.containsKey(callId)) { 1011 findConnectionForAction(callId, "handleExtrasChanged").handleExtrasChanged(extras); 1012 } else if (mConferenceById.containsKey(callId)) { 1013 findConferenceForAction(callId, "handleExtrasChanged").handleExtrasChanged(extras); 1014 } 1015 } 1016 1017 private void onPostDialContinue(String callId, boolean proceed) { 1018 Log.d(this, "onPostDialContinue(%s)", callId); 1019 findConnectionForAction(callId, "stopDtmfTone").onPostDialContinue(proceed); 1020 } 1021 1022 private void onAdapterAttached() { 1023 if (mAreAccountsInitialized) { 1024 // No need to query again if we already did it. 1025 return; 1026 } 1027 1028 mAdapter.queryRemoteConnectionServices(new RemoteServiceCallback.Stub() { 1029 @Override 1030 public void onResult( 1031 final List<ComponentName> componentNames, 1032 final List<IBinder> services) { 1033 mHandler.post(new Runnable() { 1034 @Override 1035 public void run() { 1036 for (int i = 0; i < componentNames.size() && i < services.size(); i++) { 1037 mRemoteConnectionManager.addConnectionService( 1038 componentNames.get(i), 1039 IConnectionService.Stub.asInterface(services.get(i))); 1040 } 1041 onAccountsInitialized(); 1042 Log.d(this, "remote connection services found: " + services); 1043 } 1044 }); 1045 } 1046 1047 @Override 1048 public void onError() { 1049 mHandler.post(new Runnable() { 1050 @Override 1051 public void run() { 1052 mAreAccountsInitialized = true; 1053 } 1054 }); 1055 } 1056 }); 1057 } 1058 1059 /** 1060 * Ask some other {@code ConnectionService} to create a {@code RemoteConnection} given an 1061 * incoming request. This is used by {@code ConnectionService}s that are registered with 1062 * {@link PhoneAccount#CAPABILITY_CONNECTION_MANAGER} and want to be able to manage 1063 * SIM-based incoming calls. 1064 * 1065 * @param connectionManagerPhoneAccount See description at 1066 * {@link #onCreateOutgoingConnection(PhoneAccountHandle, ConnectionRequest)}. 1067 * @param request Details about the incoming call. 1068 * @return The {@code Connection} object to satisfy this call, or {@code null} to 1069 * not handle the call. 1070 */ 1071 public final RemoteConnection createRemoteIncomingConnection( 1072 PhoneAccountHandle connectionManagerPhoneAccount, 1073 ConnectionRequest request) { 1074 return mRemoteConnectionManager.createRemoteConnection( 1075 connectionManagerPhoneAccount, request, true); 1076 } 1077 1078 /** 1079 * Ask some other {@code ConnectionService} to create a {@code RemoteConnection} given an 1080 * outgoing request. This is used by {@code ConnectionService}s that are registered with 1081 * {@link PhoneAccount#CAPABILITY_CONNECTION_MANAGER} and want to be able to use the 1082 * SIM-based {@code ConnectionService} to place its outgoing calls. 1083 * 1084 * @param connectionManagerPhoneAccount See description at 1085 * {@link #onCreateOutgoingConnection(PhoneAccountHandle, ConnectionRequest)}. 1086 * @param request Details about the incoming call. 1087 * @return The {@code Connection} object to satisfy this call, or {@code null} to 1088 * not handle the call. 1089 */ 1090 public final RemoteConnection createRemoteOutgoingConnection( 1091 PhoneAccountHandle connectionManagerPhoneAccount, 1092 ConnectionRequest request) { 1093 return mRemoteConnectionManager.createRemoteConnection( 1094 connectionManagerPhoneAccount, request, false); 1095 } 1096 1097 /** 1098 * Indicates to the relevant {@code RemoteConnectionService} that the specified 1099 * {@link RemoteConnection}s should be merged into a conference call. 1100 * <p> 1101 * If the conference request is successful, the method {@link #onRemoteConferenceAdded} will 1102 * be invoked. 1103 * 1104 * @param remoteConnection1 The first of the remote connections to conference. 1105 * @param remoteConnection2 The second of the remote connections to conference. 1106 */ 1107 public final void conferenceRemoteConnections( 1108 RemoteConnection remoteConnection1, 1109 RemoteConnection remoteConnection2) { 1110 mRemoteConnectionManager.conferenceRemoteConnections(remoteConnection1, remoteConnection2); 1111 } 1112 1113 /** 1114 * Adds a new conference call. When a conference call is created either as a result of an 1115 * explicit request via {@link #onConference} or otherwise, the connection service should supply 1116 * an instance of {@link Conference} by invoking this method. A conference call provided by this 1117 * method will persist until {@link Conference#destroy} is invoked on the conference instance. 1118 * 1119 * @param conference The new conference object. 1120 */ 1121 public final void addConference(Conference conference) { 1122 Log.d(this, "addConference: conference=%s", conference); 1123 1124 String id = addConferenceInternal(conference); 1125 if (id != null) { 1126 List<String> connectionIds = new ArrayList<>(2); 1127 for (Connection connection : conference.getConnections()) { 1128 if (mIdByConnection.containsKey(connection)) { 1129 connectionIds.add(mIdByConnection.get(connection)); 1130 } 1131 } 1132 conference.setTelecomCallId(id); 1133 ParcelableConference parcelableConference = new ParcelableConference( 1134 conference.getPhoneAccountHandle(), 1135 conference.getState(), 1136 conference.getConnectionCapabilities(), 1137 conference.getConnectionProperties(), 1138 connectionIds, 1139 conference.getVideoProvider() == null ? 1140 null : conference.getVideoProvider().getInterface(), 1141 conference.getVideoState(), 1142 conference.getConnectTimeMillis(), 1143 conference.getStatusHints(), 1144 conference.getExtras()); 1145 1146 mAdapter.addConferenceCall(id, parcelableConference); 1147 mAdapter.setVideoProvider(id, conference.getVideoProvider()); 1148 mAdapter.setVideoState(id, conference.getVideoState()); 1149 1150 // Go through any child calls and set the parent. 1151 for (Connection connection : conference.getConnections()) { 1152 String connectionId = mIdByConnection.get(connection); 1153 if (connectionId != null) { 1154 mAdapter.setIsConferenced(connectionId, id); 1155 } 1156 } 1157 } 1158 } 1159 1160 /** 1161 * Adds a connection created by the {@link ConnectionService} and informs telecom of the new 1162 * connection. 1163 * 1164 * @param phoneAccountHandle The phone account handle for the connection. 1165 * @param connection The connection to add. 1166 */ 1167 public final void addExistingConnection(PhoneAccountHandle phoneAccountHandle, 1168 Connection connection) { 1169 1170 String id = addExistingConnectionInternal(phoneAccountHandle, connection); 1171 if (id != null) { 1172 List<String> emptyList = new ArrayList<>(0); 1173 1174 ParcelableConnection parcelableConnection = new ParcelableConnection( 1175 phoneAccountHandle, 1176 connection.getState(), 1177 connection.getConnectionCapabilities(), 1178 connection.getConnectionProperties(), 1179 connection.getSupportedAudioRoutes(), 1180 connection.getAddress(), 1181 connection.getAddressPresentation(), 1182 connection.getCallerDisplayName(), 1183 connection.getCallerDisplayNamePresentation(), 1184 connection.getVideoProvider() == null ? 1185 null : connection.getVideoProvider().getInterface(), 1186 connection.getVideoState(), 1187 connection.isRingbackRequested(), 1188 connection.getAudioModeIsVoip(), 1189 connection.getConnectTimeMillis(), 1190 connection.getStatusHints(), 1191 connection.getDisconnectCause(), 1192 emptyList, 1193 connection.getExtras()); 1194 mAdapter.addExistingConnection(id, parcelableConnection); 1195 } 1196 } 1197 1198 /** 1199 * Returns all the active {@code Connection}s for which this {@code ConnectionService} 1200 * has taken responsibility. 1201 * 1202 * @return A collection of {@code Connection}s created by this {@code ConnectionService}. 1203 */ 1204 public final Collection<Connection> getAllConnections() { 1205 return mConnectionById.values(); 1206 } 1207 1208 /** 1209 * Returns all the active {@code Conference}s for which this {@code ConnectionService} 1210 * has taken responsibility. 1211 * 1212 * @return A collection of {@code Conference}s created by this {@code ConnectionService}. 1213 */ 1214 public final Collection<Conference> getAllConferences() { 1215 return mConferenceById.values(); 1216 } 1217 1218 /** 1219 * Create a {@code Connection} given an incoming request. This is used to attach to existing 1220 * incoming calls. 1221 * 1222 * @param connectionManagerPhoneAccount See description at 1223 * {@link #onCreateOutgoingConnection(PhoneAccountHandle, ConnectionRequest)}. 1224 * @param request Details about the incoming call. 1225 * @return The {@code Connection} object to satisfy this call, or {@code null} to 1226 * not handle the call. 1227 */ 1228 public Connection onCreateIncomingConnection( 1229 PhoneAccountHandle connectionManagerPhoneAccount, 1230 ConnectionRequest request) { 1231 return null; 1232 } 1233 1234 /** 1235 * Trigger recalculate functinality for conference calls. This is used when a Telephony 1236 * Connection is part of a conference controller but is not yet added to Connection 1237 * Service and hence cannot be added to the conference call. 1238 * 1239 * @hide 1240 */ 1241 public void triggerConferenceRecalculate() { 1242 } 1243 1244 /** 1245 * Create a {@code Connection} given an outgoing request. This is used to initiate new 1246 * outgoing calls. 1247 * 1248 * @param connectionManagerPhoneAccount The connection manager account to use for managing 1249 * this call. 1250 * <p> 1251 * If this parameter is not {@code null}, it means that this {@code ConnectionService} 1252 * has registered one or more {@code PhoneAccount}s having 1253 * {@link PhoneAccount#CAPABILITY_CONNECTION_MANAGER}. This parameter will contain 1254 * one of these {@code PhoneAccount}s, while the {@code request} will contain another 1255 * (usually but not always distinct) {@code PhoneAccount} to be used for actually 1256 * making the connection. 1257 * <p> 1258 * If this parameter is {@code null}, it means that this {@code ConnectionService} is 1259 * being asked to make a direct connection. The 1260 * {@link ConnectionRequest#getAccountHandle()} of parameter {@code request} will be 1261 * a {@code PhoneAccount} registered by this {@code ConnectionService} to use for 1262 * making the connection. 1263 * @param request Details about the outgoing call. 1264 * @return The {@code Connection} object to satisfy this call, or the result of an invocation 1265 * of {@link Connection#createFailedConnection(DisconnectCause)} to not handle the call. 1266 */ 1267 public Connection onCreateOutgoingConnection( 1268 PhoneAccountHandle connectionManagerPhoneAccount, 1269 ConnectionRequest request) { 1270 return null; 1271 } 1272 1273 /** 1274 * Create a {@code Connection} for a new unknown call. An unknown call is a call originating 1275 * from the ConnectionService that was neither a user-initiated outgoing call, nor an incoming 1276 * call created using 1277 * {@code TelecomManager#addNewIncomingCall(PhoneAccountHandle, android.os.Bundle)}. 1278 * 1279 * @param connectionManagerPhoneAccount 1280 * @param request 1281 * @return 1282 * 1283 * @hide 1284 */ 1285 public Connection onCreateUnknownConnection(PhoneAccountHandle connectionManagerPhoneAccount, 1286 ConnectionRequest request) { 1287 return null; 1288 } 1289 1290 /** 1291 * Conference two specified connections. Invoked when the user has made a request to merge the 1292 * specified connections into a conference call. In response, the connection service should 1293 * create an instance of {@link Conference} and pass it into {@link #addConference}. 1294 * 1295 * @param connection1 A connection to merge into a conference call. 1296 * @param connection2 A connection to merge into a conference call. 1297 */ 1298 public void onConference(Connection connection1, Connection connection2) {} 1299 1300 /** 1301 * Indicates that a remote conference has been created for existing {@link RemoteConnection}s. 1302 * When this method is invoked, this {@link ConnectionService} should create its own 1303 * representation of the conference call and send it to telecom using {@link #addConference}. 1304 * <p> 1305 * This is only relevant to {@link ConnectionService}s which are registered with 1306 * {@link PhoneAccount#CAPABILITY_CONNECTION_MANAGER}. 1307 * 1308 * @param conference The remote conference call. 1309 */ 1310 public void onRemoteConferenceAdded(RemoteConference conference) {} 1311 1312 /** 1313 * Called when an existing connection is added remotely. 1314 * @param connection The existing connection which was added. 1315 */ 1316 public void onRemoteExistingConnectionAdded(RemoteConnection connection) {} 1317 1318 /** 1319 * @hide 1320 */ 1321 public boolean containsConference(Conference conference) { 1322 return mIdByConference.containsKey(conference); 1323 } 1324 1325 /** {@hide} */ 1326 void addRemoteConference(RemoteConference remoteConference) { 1327 onRemoteConferenceAdded(remoteConference); 1328 } 1329 1330 /** {@hide} */ 1331 void addRemoteExistingConnection(RemoteConnection remoteConnection) { 1332 onRemoteExistingConnectionAdded(remoteConnection); 1333 } 1334 1335 private void onAccountsInitialized() { 1336 mAreAccountsInitialized = true; 1337 for (Runnable r : mPreInitializationConnectionRequests) { 1338 r.run(); 1339 } 1340 mPreInitializationConnectionRequests.clear(); 1341 } 1342 1343 /** 1344 * Adds an existing connection to the list of connections, identified by a new call ID unique 1345 * to this connection service. 1346 * 1347 * @param connection The connection. 1348 * @return The ID of the connection (e.g. the call-id). 1349 */ 1350 private String addExistingConnectionInternal(PhoneAccountHandle handle, Connection connection) { 1351 String id; 1352 1353 if (connection.getExtras() != null && connection.getExtras() 1354 .containsKey(Connection.EXTRA_ORIGINAL_CONNECTION_ID)) { 1355 id = connection.getExtras().getString(Connection.EXTRA_ORIGINAL_CONNECTION_ID); 1356 Log.d(this, "addExistingConnectionInternal - conn %s reusing original id %s", 1357 connection.getTelecomCallId(), id); 1358 } else if (handle == null) { 1359 // If no phone account handle was provided, we cannot be sure the call ID is unique, 1360 // so just use a random UUID. 1361 id = UUID.randomUUID().toString(); 1362 } else { 1363 // Phone account handle was provided, so use the ConnectionService class name as a 1364 // prefix for a unique incremental call ID. 1365 id = handle.getComponentName().getClassName() + "@" + getNextCallId(); 1366 } 1367 addConnection(id, connection); 1368 return id; 1369 } 1370 1371 private void addConnection(String callId, Connection connection) { 1372 connection.setTelecomCallId(callId); 1373 mConnectionById.put(callId, connection); 1374 mIdByConnection.put(connection, callId); 1375 connection.addConnectionListener(mConnectionListener); 1376 connection.setConnectionService(this); 1377 } 1378 1379 /** {@hide} */ 1380 protected void removeConnection(Connection connection) { 1381 connection.unsetConnectionService(this); 1382 connection.removeConnectionListener(mConnectionListener); 1383 String id = mIdByConnection.get(connection); 1384 if (id != null) { 1385 mConnectionById.remove(id); 1386 mIdByConnection.remove(connection); 1387 mAdapter.removeCall(id); 1388 } 1389 } 1390 1391 private String addConferenceInternal(Conference conference) { 1392 String originalId = null; 1393 if (conference.getExtras() != null && conference.getExtras() 1394 .containsKey(Connection.EXTRA_ORIGINAL_CONNECTION_ID)) { 1395 originalId = conference.getExtras().getString(Connection.EXTRA_ORIGINAL_CONNECTION_ID); 1396 Log.d(this, "addConferenceInternal: conf %s reusing original id %s", 1397 conference.getTelecomCallId(), 1398 originalId); 1399 } 1400 if (mIdByConference.containsKey(conference)) { 1401 Log.w(this, "Re-adding an existing conference: %s.", conference); 1402 } else if (conference != null) { 1403 // Conferences do not (yet) have a PhoneAccountHandle associated with them, so we 1404 // cannot determine a ConnectionService class name to associate with the ID, so use 1405 // a unique UUID (for now). 1406 String id = originalId == null ? UUID.randomUUID().toString() : originalId; 1407 mConferenceById.put(id, conference); 1408 mIdByConference.put(conference, id); 1409 conference.addListener(mConferenceListener); 1410 return id; 1411 } 1412 1413 return null; 1414 } 1415 1416 private void removeConference(Conference conference) { 1417 if (mIdByConference.containsKey(conference)) { 1418 conference.removeListener(mConferenceListener); 1419 1420 String id = mIdByConference.get(conference); 1421 mConferenceById.remove(id); 1422 mIdByConference.remove(conference); 1423 mAdapter.removeCall(id); 1424 } 1425 } 1426 1427 private Connection findConnectionForAction(String callId, String action) { 1428 if (mConnectionById.containsKey(callId)) { 1429 return mConnectionById.get(callId); 1430 } 1431 Log.w(this, "%s - Cannot find Connection %s", action, callId); 1432 return getNullConnection(); 1433 } 1434 1435 static synchronized Connection getNullConnection() { 1436 if (sNullConnection == null) { 1437 sNullConnection = new Connection() {}; 1438 } 1439 return sNullConnection; 1440 } 1441 1442 private Conference findConferenceForAction(String conferenceId, String action) { 1443 if (mConferenceById.containsKey(conferenceId)) { 1444 return mConferenceById.get(conferenceId); 1445 } 1446 Log.w(this, "%s - Cannot find conference %s", action, conferenceId); 1447 return getNullConference(); 1448 } 1449 1450 private List<String> createConnectionIdList(List<Connection> connections) { 1451 List<String> ids = new ArrayList<>(); 1452 for (Connection c : connections) { 1453 if (mIdByConnection.containsKey(c)) { 1454 ids.add(mIdByConnection.get(c)); 1455 } 1456 } 1457 Collections.sort(ids); 1458 return ids; 1459 } 1460 1461 /** 1462 * Builds a list of {@link Connection} and {@link Conference} IDs based on the list of 1463 * {@link Conferenceable}s passed in. 1464 * 1465 * @param conferenceables The {@link Conferenceable} connections and conferences. 1466 * @return List of string conference and call Ids. 1467 */ 1468 private List<String> createIdList(List<Conferenceable> conferenceables) { 1469 List<String> ids = new ArrayList<>(); 1470 for (Conferenceable c : conferenceables) { 1471 // Only allow Connection and Conference conferenceables. 1472 if (c instanceof Connection) { 1473 Connection connection = (Connection) c; 1474 if (mIdByConnection.containsKey(connection)) { 1475 ids.add(mIdByConnection.get(connection)); 1476 } 1477 } else if (c instanceof Conference) { 1478 Conference conference = (Conference) c; 1479 if (mIdByConference.containsKey(conference)) { 1480 ids.add(mIdByConference.get(conference)); 1481 } 1482 } 1483 } 1484 Collections.sort(ids); 1485 return ids; 1486 } 1487 1488 private Conference getNullConference() { 1489 if (sNullConference == null) { 1490 sNullConference = new Conference(null) {}; 1491 } 1492 return sNullConference; 1493 } 1494 1495 private void endAllConnections() { 1496 // Unbound from telecomm. We should end all connections and conferences. 1497 for (Connection connection : mIdByConnection.keySet()) { 1498 // only operate on top-level calls. Conference calls will be removed on their own. 1499 if (connection.getConference() == null) { 1500 connection.onDisconnect(); 1501 } 1502 } 1503 for (Conference conference : mIdByConference.keySet()) { 1504 conference.onDisconnect(); 1505 } 1506 } 1507 1508 /** 1509 * Retrieves the next call ID as maintainted by the connection service. 1510 * 1511 * @return The call ID. 1512 */ 1513 private int getNextCallId() { 1514 synchronized(mIdSyncRoot) { 1515 return ++mId; 1516 } 1517 } 1518} 1519