ConnectionService.java revision a663f86fd30c952a3b747763d2faea709eccbe91
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.Handler; 25import android.os.IBinder; 26import android.os.Looper; 27import android.os.Message; 28 29import com.android.internal.os.SomeArgs; 30import com.android.internal.telecom.IConnectionService; 31import com.android.internal.telecom.IConnectionServiceAdapter; 32import com.android.internal.telecom.RemoteServiceCallback; 33 34import java.util.ArrayList; 35import java.util.Collection; 36import java.util.Collections; 37import java.util.List; 38import java.util.Map; 39import java.util.UUID; 40import java.util.concurrent.ConcurrentHashMap; 41 42/** 43 * {@code ConnectionService} is an abstract service that should be implemented by any app which can 44 * make phone calls and want those calls to be integrated into the built-in phone app. 45 * Once implemented, the {@code ConnectionService} needs two additional steps before it will be 46 * integrated into the phone app: 47 * <p> 48 * 1. <i>Registration in AndroidManifest.xml</i> 49 * <br/> 50 * <pre> 51 * <service android:name="com.example.package.MyConnectionService" 52 * android:label="@string/some_label_for_my_connection_service" 53 * android:permission="android.permission.BIND_CONNECTION_SERVICE"> 54 * <intent-filter> 55 * <action android:name="android.telecom.ConnectionService" /> 56 * </intent-filter> 57 * </service> 58 * </pre> 59 * <p> 60 * 2. <i> Registration of {@link PhoneAccount} with {@link TelecomManager}.</i> 61 * <br/> 62 * See {@link PhoneAccount} and {@link TelecomManager#registerPhoneAccount} for more information. 63 * <p> 64 * Once registered and enabled by the user in the dialer settings, telecom will bind to a 65 * {@code ConnectionService} implementation when it wants that {@code ConnectionService} to place 66 * a call or the service has indicated that is has an incoming call through 67 * {@link TelecomManager#addNewIncomingCall}. The {@code ConnectionService} can then expect a call 68 * to {@link #onCreateIncomingConnection} or {@link #onCreateOutgoingConnection} wherein it 69 * should provide a new instance of a {@link Connection} object. It is through this 70 * {@link Connection} object that telecom receives state updates and the {@code ConnectionService} 71 * receives call-commands such as answer, reject, hold and disconnect. 72 * <p> 73 * When there are no more live calls, telecom will unbind from the {@code ConnectionService}. 74 */ 75public abstract class ConnectionService extends Service { 76 /** 77 * The {@link Intent} that must be declared as handled by the service. 78 */ 79 @SdkConstant(SdkConstant.SdkConstantType.SERVICE_ACTION) 80 public static final String SERVICE_INTERFACE = "android.telecom.ConnectionService"; 81 82 // Flag controlling whether PII is emitted into the logs 83 private static final boolean PII_DEBUG = Log.isLoggable(android.util.Log.DEBUG); 84 85 private static final int MSG_ADD_CONNECTION_SERVICE_ADAPTER = 1; 86 private static final int MSG_CREATE_CONNECTION = 2; 87 private static final int MSG_ABORT = 3; 88 private static final int MSG_ANSWER = 4; 89 private static final int MSG_REJECT = 5; 90 private static final int MSG_DISCONNECT = 6; 91 private static final int MSG_HOLD = 7; 92 private static final int MSG_UNHOLD = 8; 93 private static final int MSG_ON_AUDIO_STATE_CHANGED = 9; 94 private static final int MSG_PLAY_DTMF_TONE = 10; 95 private static final int MSG_STOP_DTMF_TONE = 11; 96 private static final int MSG_CONFERENCE = 12; 97 private static final int MSG_SPLIT_FROM_CONFERENCE = 13; 98 private static final int MSG_ON_POST_DIAL_CONTINUE = 14; 99 private static final int MSG_REMOVE_CONNECTION_SERVICE_ADAPTER = 16; 100 private static final int MSG_ANSWER_VIDEO = 17; 101 private static final int MSG_MERGE_CONFERENCE = 18; 102 private static final int MSG_SWAP_CONFERENCE = 19; 103 104 private static Connection sNullConnection; 105 106 private final Map<String, Connection> mConnectionById = new ConcurrentHashMap<>(); 107 private final Map<Connection, String> mIdByConnection = new ConcurrentHashMap<>(); 108 private final Map<String, Conference> mConferenceById = new ConcurrentHashMap<>(); 109 private final Map<Conference, String> mIdByConference = new ConcurrentHashMap<>(); 110 private final RemoteConnectionManager mRemoteConnectionManager = 111 new RemoteConnectionManager(this); 112 private final List<Runnable> mPreInitializationConnectionRequests = new ArrayList<>(); 113 private final ConnectionServiceAdapter mAdapter = new ConnectionServiceAdapter(); 114 115 private boolean mAreAccountsInitialized = false; 116 private Conference sNullConference; 117 118 private final IBinder mBinder = new IConnectionService.Stub() { 119 @Override 120 public void addConnectionServiceAdapter(IConnectionServiceAdapter adapter) { 121 mHandler.obtainMessage(MSG_ADD_CONNECTION_SERVICE_ADAPTER, adapter).sendToTarget(); 122 } 123 124 public void removeConnectionServiceAdapter(IConnectionServiceAdapter adapter) { 125 mHandler.obtainMessage(MSG_REMOVE_CONNECTION_SERVICE_ADAPTER, adapter).sendToTarget(); 126 } 127 128 @Override 129 public void createConnection( 130 PhoneAccountHandle connectionManagerPhoneAccount, 131 String id, 132 ConnectionRequest request, 133 boolean isIncoming, 134 boolean isUnknown) { 135 SomeArgs args = SomeArgs.obtain(); 136 args.arg1 = connectionManagerPhoneAccount; 137 args.arg2 = id; 138 args.arg3 = request; 139 args.argi1 = isIncoming ? 1 : 0; 140 args.argi2 = isUnknown ? 1 : 0; 141 mHandler.obtainMessage(MSG_CREATE_CONNECTION, args).sendToTarget(); 142 } 143 144 @Override 145 public void abort(String callId) { 146 mHandler.obtainMessage(MSG_ABORT, callId).sendToTarget(); 147 } 148 149 @Override 150 /** @hide */ 151 public void answerVideo(String callId, int videoState) { 152 SomeArgs args = SomeArgs.obtain(); 153 args.arg1 = callId; 154 args.argi1 = videoState; 155 mHandler.obtainMessage(MSG_ANSWER_VIDEO, args).sendToTarget(); 156 } 157 158 @Override 159 public void answer(String callId) { 160 mHandler.obtainMessage(MSG_ANSWER, callId).sendToTarget(); 161 } 162 163 @Override 164 public void reject(String callId) { 165 mHandler.obtainMessage(MSG_REJECT, callId).sendToTarget(); 166 } 167 168 @Override 169 public void disconnect(String callId) { 170 mHandler.obtainMessage(MSG_DISCONNECT, callId).sendToTarget(); 171 } 172 173 @Override 174 public void hold(String callId) { 175 mHandler.obtainMessage(MSG_HOLD, callId).sendToTarget(); 176 } 177 178 @Override 179 public void unhold(String callId) { 180 mHandler.obtainMessage(MSG_UNHOLD, callId).sendToTarget(); 181 } 182 183 @Override 184 public void onAudioStateChanged(String callId, AudioState audioState) { 185 SomeArgs args = SomeArgs.obtain(); 186 args.arg1 = callId; 187 args.arg2 = audioState; 188 mHandler.obtainMessage(MSG_ON_AUDIO_STATE_CHANGED, args).sendToTarget(); 189 } 190 191 @Override 192 public void playDtmfTone(String callId, char digit) { 193 mHandler.obtainMessage(MSG_PLAY_DTMF_TONE, digit, 0, callId).sendToTarget(); 194 } 195 196 @Override 197 public void stopDtmfTone(String callId) { 198 mHandler.obtainMessage(MSG_STOP_DTMF_TONE, callId).sendToTarget(); 199 } 200 201 @Override 202 public void conference(String callId1, String callId2) { 203 SomeArgs args = SomeArgs.obtain(); 204 args.arg1 = callId1; 205 args.arg2 = callId2; 206 mHandler.obtainMessage(MSG_CONFERENCE, args).sendToTarget(); 207 } 208 209 @Override 210 public void splitFromConference(String callId) { 211 mHandler.obtainMessage(MSG_SPLIT_FROM_CONFERENCE, callId).sendToTarget(); 212 } 213 214 @Override 215 public void mergeConference(String callId) { 216 mHandler.obtainMessage(MSG_MERGE_CONFERENCE, callId).sendToTarget(); 217 } 218 219 @Override 220 public void swapConference(String callId) { 221 mHandler.obtainMessage(MSG_SWAP_CONFERENCE, callId).sendToTarget(); 222 } 223 224 @Override 225 public void onPostDialContinue(String callId, boolean proceed) { 226 SomeArgs args = SomeArgs.obtain(); 227 args.arg1 = callId; 228 args.argi1 = proceed ? 1 : 0; 229 mHandler.obtainMessage(MSG_ON_POST_DIAL_CONTINUE, args).sendToTarget(); 230 } 231 }; 232 233 private final Handler mHandler = new Handler(Looper.getMainLooper()) { 234 @Override 235 public void handleMessage(Message msg) { 236 switch (msg.what) { 237 case MSG_ADD_CONNECTION_SERVICE_ADAPTER: 238 mAdapter.addAdapter((IConnectionServiceAdapter) msg.obj); 239 onAdapterAttached(); 240 break; 241 case MSG_REMOVE_CONNECTION_SERVICE_ADAPTER: 242 mAdapter.removeAdapter((IConnectionServiceAdapter) msg.obj); 243 break; 244 case MSG_CREATE_CONNECTION: { 245 SomeArgs args = (SomeArgs) msg.obj; 246 try { 247 final PhoneAccountHandle connectionManagerPhoneAccount = 248 (PhoneAccountHandle) args.arg1; 249 final String id = (String) args.arg2; 250 final ConnectionRequest request = (ConnectionRequest) args.arg3; 251 final boolean isIncoming = args.argi1 == 1; 252 final boolean isUnknown = args.argi2 == 1; 253 if (!mAreAccountsInitialized) { 254 Log.d(this, "Enqueueing pre-init request %s", id); 255 mPreInitializationConnectionRequests.add(new Runnable() { 256 @Override 257 public void run() { 258 createConnection( 259 connectionManagerPhoneAccount, 260 id, 261 request, 262 isIncoming, 263 isUnknown); 264 } 265 }); 266 } else { 267 createConnection( 268 connectionManagerPhoneAccount, 269 id, 270 request, 271 isIncoming, 272 isUnknown); 273 } 274 } finally { 275 args.recycle(); 276 } 277 break; 278 } 279 case MSG_ABORT: 280 abort((String) msg.obj); 281 break; 282 case MSG_ANSWER: 283 answer((String) msg.obj); 284 break; 285 case MSG_ANSWER_VIDEO: { 286 SomeArgs args = (SomeArgs) msg.obj; 287 try { 288 String callId = (String) args.arg1; 289 int videoState = args.argi1; 290 answerVideo(callId, videoState); 291 } finally { 292 args.recycle(); 293 } 294 break; 295 } 296 case MSG_REJECT: 297 reject((String) msg.obj); 298 break; 299 case MSG_DISCONNECT: 300 disconnect((String) msg.obj); 301 break; 302 case MSG_HOLD: 303 hold((String) msg.obj); 304 break; 305 case MSG_UNHOLD: 306 unhold((String) msg.obj); 307 break; 308 case MSG_ON_AUDIO_STATE_CHANGED: { 309 SomeArgs args = (SomeArgs) msg.obj; 310 try { 311 String callId = (String) args.arg1; 312 AudioState audioState = (AudioState) args.arg2; 313 onAudioStateChanged(callId, audioState); 314 } finally { 315 args.recycle(); 316 } 317 break; 318 } 319 case MSG_PLAY_DTMF_TONE: 320 playDtmfTone((String) msg.obj, (char) msg.arg1); 321 break; 322 case MSG_STOP_DTMF_TONE: 323 stopDtmfTone((String) msg.obj); 324 break; 325 case MSG_CONFERENCE: { 326 SomeArgs args = (SomeArgs) msg.obj; 327 try { 328 String callId1 = (String) args.arg1; 329 String callId2 = (String) args.arg2; 330 conference(callId1, callId2); 331 } finally { 332 args.recycle(); 333 } 334 break; 335 } 336 case MSG_SPLIT_FROM_CONFERENCE: 337 splitFromConference((String) msg.obj); 338 break; 339 case MSG_MERGE_CONFERENCE: 340 mergeConference((String) msg.obj); 341 break; 342 case MSG_SWAP_CONFERENCE: 343 swapConference((String) msg.obj); 344 break; 345 case MSG_ON_POST_DIAL_CONTINUE: { 346 SomeArgs args = (SomeArgs) msg.obj; 347 try { 348 String callId = (String) args.arg1; 349 boolean proceed = (args.argi1 == 1); 350 onPostDialContinue(callId, proceed); 351 } finally { 352 args.recycle(); 353 } 354 break; 355 } 356 default: 357 break; 358 } 359 } 360 }; 361 362 private final Conference.Listener mConferenceListener = new Conference.Listener() { 363 @Override 364 public void onStateChanged(Conference conference, int oldState, int newState) { 365 String id = mIdByConference.get(conference); 366 switch (newState) { 367 case Connection.STATE_ACTIVE: 368 mAdapter.setActive(id); 369 break; 370 case Connection.STATE_HOLDING: 371 mAdapter.setOnHold(id); 372 break; 373 case Connection.STATE_DISCONNECTED: 374 // handled by onDisconnected 375 break; 376 } 377 } 378 379 @Override 380 public void onDisconnected(Conference conference, DisconnectCause disconnectCause) { 381 String id = mIdByConference.get(conference); 382 mAdapter.setDisconnected(id, disconnectCause); 383 } 384 385 @Override 386 public void onConnectionAdded(Conference conference, Connection connection) { 387 } 388 389 @Override 390 public void onConnectionRemoved(Conference conference, Connection connection) { 391 } 392 393 @Override 394 public void onConferenceableConnectionsChanged( 395 Conference conference, List<Connection> conferenceableConnections) { 396 mAdapter.setConferenceableConnections( 397 mIdByConference.get(conference), 398 createConnectionIdList(conferenceableConnections)); 399 } 400 401 @Override 402 public void onDestroyed(Conference conference) { 403 removeConference(conference); 404 } 405 406 @Override 407 public void onCapabilitiesChanged(Conference conference, int capabilities) { 408 String id = mIdByConference.get(conference); 409 Log.d(this, "call capabilities: conference: %s", 410 PhoneCapabilities.toString(capabilities)); 411 mAdapter.setCallCapabilities(id, capabilities); 412 } 413 }; 414 415 private final Connection.Listener mConnectionListener = new Connection.Listener() { 416 @Override 417 public void onStateChanged(Connection c, int state) { 418 String id = mIdByConnection.get(c); 419 Log.d(this, "Adapter set state %s %s", id, Connection.stateToString(state)); 420 switch (state) { 421 case Connection.STATE_ACTIVE: 422 mAdapter.setActive(id); 423 break; 424 case Connection.STATE_DIALING: 425 mAdapter.setDialing(id); 426 break; 427 case Connection.STATE_DISCONNECTED: 428 // Handled in onDisconnected() 429 break; 430 case Connection.STATE_HOLDING: 431 mAdapter.setOnHold(id); 432 break; 433 case Connection.STATE_NEW: 434 // Nothing to tell Telecom 435 break; 436 case Connection.STATE_RINGING: 437 mAdapter.setRinging(id); 438 break; 439 } 440 } 441 442 @Override 443 public void onDisconnected(Connection c, DisconnectCause disconnectCause) { 444 String id = mIdByConnection.get(c); 445 Log.d(this, "Adapter set disconnected %s", disconnectCause); 446 mAdapter.setDisconnected(id, disconnectCause); 447 } 448 449 @Override 450 public void onVideoStateChanged(Connection c, int videoState) { 451 String id = mIdByConnection.get(c); 452 Log.d(this, "Adapter set video state %d", videoState); 453 mAdapter.setVideoState(id, videoState); 454 } 455 456 @Override 457 public void onAddressChanged(Connection c, Uri address, int presentation) { 458 String id = mIdByConnection.get(c); 459 mAdapter.setAddress(id, address, presentation); 460 } 461 462 @Override 463 public void onCallerDisplayNameChanged( 464 Connection c, String callerDisplayName, int presentation) { 465 String id = mIdByConnection.get(c); 466 mAdapter.setCallerDisplayName(id, callerDisplayName, presentation); 467 } 468 469 @Override 470 public void onDestroyed(Connection c) { 471 removeConnection(c); 472 } 473 474 @Override 475 public void onPostDialWait(Connection c, String remaining) { 476 String id = mIdByConnection.get(c); 477 Log.d(this, "Adapter onPostDialWait %s, %s", c, remaining); 478 mAdapter.onPostDialWait(id, remaining); 479 } 480 481 @Override 482 public void onRingbackRequested(Connection c, boolean ringback) { 483 String id = mIdByConnection.get(c); 484 Log.d(this, "Adapter onRingback %b", ringback); 485 mAdapter.setRingbackRequested(id, ringback); 486 } 487 488 @Override 489 public void onCallCapabilitiesChanged(Connection c, int capabilities) { 490 String id = mIdByConnection.get(c); 491 Log.d(this, "capabilities: parcelableconnection: %s", 492 PhoneCapabilities.toString(capabilities)); 493 mAdapter.setCallCapabilities(id, capabilities); 494 } 495 496 @Override 497 public void onVideoProviderChanged(Connection c, Connection.VideoProvider videoProvider) { 498 String id = mIdByConnection.get(c); 499 mAdapter.setVideoProvider(id, videoProvider); 500 } 501 502 @Override 503 public void onAudioModeIsVoipChanged(Connection c, boolean isVoip) { 504 String id = mIdByConnection.get(c); 505 mAdapter.setIsVoipAudioMode(id, isVoip); 506 } 507 508 @Override 509 public void onStatusHintsChanged(Connection c, StatusHints statusHints) { 510 String id = mIdByConnection.get(c); 511 mAdapter.setStatusHints(id, statusHints); 512 } 513 514 @Override 515 public void onConferenceableConnectionsChanged( 516 Connection connection, List<Connection> conferenceableConnections) { 517 mAdapter.setConferenceableConnections( 518 mIdByConnection.get(connection), 519 createConnectionIdList(conferenceableConnections)); 520 } 521 522 @Override 523 public void onConferenceChanged(Connection connection, Conference conference) { 524 String id = mIdByConnection.get(connection); 525 if (id != null) { 526 String conferenceId = null; 527 if (conference != null) { 528 conferenceId = mIdByConference.get(conference); 529 } 530 mAdapter.setIsConferenced(id, conferenceId); 531 } 532 } 533 }; 534 535 /** {@inheritDoc} */ 536 @Override 537 public final IBinder onBind(Intent intent) { 538 return mBinder; 539 } 540 541 /** {@inheritDoc} */ 542 @Override 543 public boolean onUnbind(Intent intent) { 544 endAllConnections(); 545 return super.onUnbind(intent); 546 } 547 548 /** 549 * This can be used by telecom to either create a new outgoing call or attach to an existing 550 * incoming call. In either case, telecom will cycle through a set of services and call 551 * createConnection util a connection service cancels the process or completes it successfully. 552 */ 553 private void createConnection( 554 final PhoneAccountHandle callManagerAccount, 555 final String callId, 556 final ConnectionRequest request, 557 boolean isIncoming, 558 boolean isUnknown) { 559 Log.d(this, "createConnection, callManagerAccount: %s, callId: %s, request: %s, " + 560 "isIncoming: %b, isUnknown: %b", callManagerAccount, callId, request, isIncoming, 561 isUnknown); 562 563 Connection connection = isUnknown ? onCreateUnknownConnection(callManagerAccount, request) 564 : isIncoming ? onCreateIncomingConnection(callManagerAccount, request) 565 : onCreateOutgoingConnection(callManagerAccount, request); 566 Log.d(this, "createConnection, connection: %s", connection); 567 if (connection == null) { 568 connection = Connection.createFailedConnection( 569 new DisconnectCause(DisconnectCause.ERROR)); 570 } 571 572 if (connection.getState() != Connection.STATE_DISCONNECTED) { 573 addConnection(callId, connection); 574 } 575 576 Uri address = connection.getAddress(); 577 String number = address == null ? "null" : address.getSchemeSpecificPart(); 578 Log.v(this, "createConnection, number: %s, state: %s, capabilities: %s", 579 Connection.toLogSafePhoneNumber(number), 580 Connection.stateToString(connection.getState()), 581 PhoneCapabilities.toString(connection.getCallCapabilities())); 582 583 Log.d(this, "createConnection, calling handleCreateConnectionSuccessful %s", callId); 584 mAdapter.handleCreateConnectionComplete( 585 callId, 586 request, 587 new ParcelableConnection( 588 request.getAccountHandle(), 589 connection.getState(), 590 connection.getCallCapabilities(), 591 connection.getAddress(), 592 connection.getAddressPresentation(), 593 connection.getCallerDisplayName(), 594 connection.getCallerDisplayNamePresentation(), 595 connection.getVideoProvider() == null ? 596 null : connection.getVideoProvider().getInterface(), 597 connection.getVideoState(), 598 connection.isRingbackRequested(), 599 connection.getAudioModeIsVoip(), 600 connection.getStatusHints(), 601 connection.getDisconnectCause(), 602 createConnectionIdList(connection.getConferenceableConnections()))); 603 } 604 605 private void abort(String callId) { 606 Log.d(this, "abort %s", callId); 607 findConnectionForAction(callId, "abort").onAbort(); 608 } 609 610 private void answerVideo(String callId, int videoState) { 611 Log.d(this, "answerVideo %s", callId); 612 findConnectionForAction(callId, "answer").onAnswer(videoState); 613 } 614 615 private void answer(String callId) { 616 Log.d(this, "answer %s", callId); 617 findConnectionForAction(callId, "answer").onAnswer(); 618 } 619 620 private void reject(String callId) { 621 Log.d(this, "reject %s", callId); 622 findConnectionForAction(callId, "reject").onReject(); 623 } 624 625 private void disconnect(String callId) { 626 Log.d(this, "disconnect %s", callId); 627 if (mConnectionById.containsKey(callId)) { 628 findConnectionForAction(callId, "disconnect").onDisconnect(); 629 } else { 630 findConferenceForAction(callId, "disconnect").onDisconnect(); 631 } 632 } 633 634 private void hold(String callId) { 635 Log.d(this, "hold %s", callId); 636 if (mConnectionById.containsKey(callId)) { 637 findConnectionForAction(callId, "hold").onHold(); 638 } else { 639 findConferenceForAction(callId, "hold").onHold(); 640 } 641 } 642 643 private void unhold(String callId) { 644 Log.d(this, "unhold %s", callId); 645 if (mConnectionById.containsKey(callId)) { 646 findConnectionForAction(callId, "unhold").onUnhold(); 647 } else { 648 findConferenceForAction(callId, "unhold").onUnhold(); 649 } 650 } 651 652 private void onAudioStateChanged(String callId, AudioState audioState) { 653 Log.d(this, "onAudioStateChanged %s %s", callId, audioState); 654 if (mConnectionById.containsKey(callId)) { 655 findConnectionForAction(callId, "onAudioStateChanged").setAudioState(audioState); 656 } else { 657 findConferenceForAction(callId, "onAudioStateChanged").setAudioState(audioState); 658 } 659 } 660 661 private void playDtmfTone(String callId, char digit) { 662 Log.d(this, "playDtmfTone %s %c", callId, digit); 663 if (mConnectionById.containsKey(callId)) { 664 findConnectionForAction(callId, "playDtmfTone").onPlayDtmfTone(digit); 665 } else { 666 findConferenceForAction(callId, "playDtmfTone").onPlayDtmfTone(digit); 667 } 668 } 669 670 private void stopDtmfTone(String callId) { 671 Log.d(this, "stopDtmfTone %s", callId); 672 if (mConnectionById.containsKey(callId)) { 673 findConnectionForAction(callId, "stopDtmfTone").onStopDtmfTone(); 674 } else { 675 findConferenceForAction(callId, "stopDtmfTone").onStopDtmfTone(); 676 } 677 } 678 679 private void conference(String callId1, String callId2) { 680 Log.d(this, "conference %s, %s", callId1, callId2); 681 682 Connection connection2 = findConnectionForAction(callId2, "conference"); 683 if (connection2 == getNullConnection()) { 684 Log.w(this, "Connection2 missing in conference request %s.", callId2); 685 return; 686 } 687 688 Connection connection1 = findConnectionForAction(callId1, "conference"); 689 if (connection1 == getNullConnection()) { 690 Conference conference1 = findConferenceForAction(callId1, "addConnection"); 691 if (conference1 == getNullConference()) { 692 Log.w(this, 693 "Connection1 or Conference1 missing in conference request %s.", 694 callId1); 695 } else { 696 conference1.onMerge(connection2); 697 } 698 } else { 699 onConference(connection1, connection2); 700 } 701 } 702 703 private void splitFromConference(String callId) { 704 Log.d(this, "splitFromConference(%s)", callId); 705 706 Connection connection = findConnectionForAction(callId, "splitFromConference"); 707 if (connection == getNullConnection()) { 708 Log.w(this, "Connection missing in conference request %s.", callId); 709 return; 710 } 711 712 Conference conference = connection.getConference(); 713 if (conference != null) { 714 conference.onSeparate(connection); 715 } 716 } 717 718 private void mergeConference(String callId) { 719 Log.d(this, "mergeConference(%s)", callId); 720 Conference conference = findConferenceForAction(callId, "mergeConference"); 721 if (conference != null) { 722 conference.onMerge(); 723 } 724 } 725 726 private void swapConference(String callId) { 727 Log.d(this, "swapConference(%s)", callId); 728 Conference conference = findConferenceForAction(callId, "swapConference"); 729 if (conference != null) { 730 conference.onSwap(); 731 } 732 } 733 734 private void onPostDialContinue(String callId, boolean proceed) { 735 Log.d(this, "onPostDialContinue(%s)", callId); 736 findConnectionForAction(callId, "stopDtmfTone").onPostDialContinue(proceed); 737 } 738 739 private void onAdapterAttached() { 740 if (mAreAccountsInitialized) { 741 // No need to query again if we already did it. 742 return; 743 } 744 745 mAdapter.queryRemoteConnectionServices(new RemoteServiceCallback.Stub() { 746 @Override 747 public void onResult( 748 final List<ComponentName> componentNames, 749 final List<IBinder> services) { 750 mHandler.post(new Runnable() { 751 @Override 752 public void run() { 753 for (int i = 0; i < componentNames.size() && i < services.size(); i++) { 754 mRemoteConnectionManager.addConnectionService( 755 componentNames.get(i), 756 IConnectionService.Stub.asInterface(services.get(i))); 757 } 758 onAccountsInitialized(); 759 Log.d(this, "remote connection services found: " + services); 760 } 761 }); 762 } 763 764 @Override 765 public void onError() { 766 mHandler.post(new Runnable() { 767 @Override 768 public void run() { 769 mAreAccountsInitialized = true; 770 } 771 }); 772 } 773 }); 774 } 775 776 /** 777 * Ask some other {@code ConnectionService} to create a {@code RemoteConnection} given an 778 * incoming request. This is used by {@code ConnectionService}s that are registered with 779 * {@link PhoneAccount#CAPABILITY_CONNECTION_MANAGER} and want to be able to manage 780 * SIM-based incoming calls. 781 * 782 * @param connectionManagerPhoneAccount See description at 783 * {@link #onCreateOutgoingConnection(PhoneAccountHandle, ConnectionRequest)}. 784 * @param request Details about the incoming call. 785 * @return The {@code Connection} object to satisfy this call, or {@code null} to 786 * not handle the call. 787 */ 788 public final RemoteConnection createRemoteIncomingConnection( 789 PhoneAccountHandle connectionManagerPhoneAccount, 790 ConnectionRequest request) { 791 return mRemoteConnectionManager.createRemoteConnection( 792 connectionManagerPhoneAccount, request, true); 793 } 794 795 /** 796 * Ask some other {@code ConnectionService} to create a {@code RemoteConnection} given an 797 * outgoing request. This is used by {@code ConnectionService}s that are registered with 798 * {@link PhoneAccount#CAPABILITY_CONNECTION_MANAGER} and want to be able to use the 799 * SIM-based {@code ConnectionService} to place its outgoing calls. 800 * 801 * @param connectionManagerPhoneAccount See description at 802 * {@link #onCreateOutgoingConnection(PhoneAccountHandle, ConnectionRequest)}. 803 * @param request Details about the incoming call. 804 * @return The {@code Connection} object to satisfy this call, or {@code null} to 805 * not handle the call. 806 */ 807 public final RemoteConnection createRemoteOutgoingConnection( 808 PhoneAccountHandle connectionManagerPhoneAccount, 809 ConnectionRequest request) { 810 return mRemoteConnectionManager.createRemoteConnection( 811 connectionManagerPhoneAccount, request, false); 812 } 813 814 /** 815 * Indicates to the relevant {@code RemoteConnectionService} that the specified 816 * {@link RemoteConnection}s should be merged into a conference call. 817 * <p> 818 * If the conference request is successful, the method {@link #onRemoteConferenceAdded} will 819 * be invoked. 820 * 821 * @param remoteConnection1 The first of the remote connections to conference. 822 * @param remoteConnection2 The second of the remote connections to conference. 823 */ 824 public final void conferenceRemoteConnections( 825 RemoteConnection remoteConnection1, 826 RemoteConnection remoteConnection2) { 827 mRemoteConnectionManager.conferenceRemoteConnections(remoteConnection1, remoteConnection2); 828 } 829 830 /** 831 * Adds a new conference call. When a conference call is created either as a result of an 832 * explicit request via {@link #onConference} or otherwise, the connection service should supply 833 * an instance of {@link Conference} by invoking this method. A conference call provided by this 834 * method will persist until {@link Conference#destroy} is invoked on the conference instance. 835 * 836 * @param conference The new conference object. 837 */ 838 public final void addConference(Conference conference) { 839 String id = addConferenceInternal(conference); 840 if (id != null) { 841 List<String> connectionIds = new ArrayList<>(2); 842 for (Connection connection : conference.getConnections()) { 843 if (mIdByConnection.containsKey(connection)) { 844 connectionIds.add(mIdByConnection.get(connection)); 845 } 846 } 847 ParcelableConference parcelableConference = new ParcelableConference( 848 conference.getPhoneAccountHandle(), 849 conference.getState(), 850 conference.getCapabilities(), 851 connectionIds); 852 mAdapter.addConferenceCall(id, parcelableConference); 853 854 // Go through any child calls and set the parent. 855 for (Connection connection : conference.getConnections()) { 856 String connectionId = mIdByConnection.get(connection); 857 if (connectionId != null) { 858 mAdapter.setIsConferenced(connectionId, id); 859 } 860 } 861 } 862 } 863 864 /** 865 * Adds a connection created by the {@link ConnectionService} and informs telecom of the new 866 * connection. 867 * 868 * @param phoneAccountHandle The phone account handle for the connection. 869 * @param connection The connection to add. 870 */ 871 public final void addExistingConnection(PhoneAccountHandle phoneAccountHandle, 872 Connection connection) { 873 874 String id = addExistingConnectionInternal(connection); 875 if (id != null) { 876 List<String> emptyList = new ArrayList<>(0); 877 878 ParcelableConnection parcelableConnection = new ParcelableConnection( 879 phoneAccountHandle, 880 connection.getState(), 881 connection.getCallCapabilities(), 882 connection.getAddress(), 883 connection.getAddressPresentation(), 884 connection.getCallerDisplayName(), 885 connection.getCallerDisplayNamePresentation(), 886 connection.getVideoProvider() == null ? 887 null : connection.getVideoProvider().getInterface(), 888 connection.getVideoState(), 889 connection.isRingbackRequested(), 890 connection.getAudioModeIsVoip(), 891 connection.getStatusHints(), 892 connection.getDisconnectCause(), 893 emptyList); 894 mAdapter.addExistingConnection(id, parcelableConnection); 895 } 896 } 897 898 /** 899 * Returns all the active {@code Connection}s for which this {@code ConnectionService} 900 * has taken responsibility. 901 * 902 * @return A collection of {@code Connection}s created by this {@code ConnectionService}. 903 */ 904 public final Collection<Connection> getAllConnections() { 905 return mConnectionById.values(); 906 } 907 908 /** 909 * Create a {@code Connection} given an incoming request. This is used to attach to existing 910 * incoming calls. 911 * 912 * @param connectionManagerPhoneAccount See description at 913 * {@link #onCreateOutgoingConnection(PhoneAccountHandle, ConnectionRequest)}. 914 * @param request Details about the incoming call. 915 * @return The {@code Connection} object to satisfy this call, or {@code null} to 916 * not handle the call. 917 */ 918 public Connection onCreateIncomingConnection( 919 PhoneAccountHandle connectionManagerPhoneAccount, 920 ConnectionRequest request) { 921 return null; 922 } 923 924 /** 925 * Create a {@code Connection} given an outgoing request. This is used to initiate new 926 * outgoing calls. 927 * 928 * @param connectionManagerPhoneAccount The connection manager account to use for managing 929 * this call. 930 * <p> 931 * If this parameter is not {@code null}, it means that this {@code ConnectionService} 932 * has registered one or more {@code PhoneAccount}s having 933 * {@link PhoneAccount#CAPABILITY_CONNECTION_MANAGER}. This parameter will contain 934 * one of these {@code PhoneAccount}s, while the {@code request} will contain another 935 * (usually but not always distinct) {@code PhoneAccount} to be used for actually 936 * making the connection. 937 * <p> 938 * If this parameter is {@code null}, it means that this {@code ConnectionService} is 939 * being asked to make a direct connection. The 940 * {@link ConnectionRequest#getAccountHandle()} of parameter {@code request} will be 941 * a {@code PhoneAccount} registered by this {@code ConnectionService} to use for 942 * making the connection. 943 * @param request Details about the outgoing call. 944 * @return The {@code Connection} object to satisfy this call, or the result of an invocation 945 * of {@link Connection#createFailedConnection(DisconnectCause)} to not handle the call. 946 */ 947 public Connection onCreateOutgoingConnection( 948 PhoneAccountHandle connectionManagerPhoneAccount, 949 ConnectionRequest request) { 950 return null; 951 } 952 953 /** 954 * Create a {@code Connection} for a new unknown call. An unknown call is a call originating 955 * from the ConnectionService that was neither a user-initiated outgoing call, nor an incoming 956 * call created using 957 * {@code TelecomManager#addNewIncomingCall(PhoneAccountHandle, android.os.Bundle)}. 958 * 959 * @param connectionManagerPhoneAccount 960 * @param request 961 * @return 962 * 963 * @hide 964 */ 965 public Connection onCreateUnknownConnection(PhoneAccountHandle connectionManagerPhoneAccount, 966 ConnectionRequest request) { 967 return null; 968 } 969 970 /** 971 * Conference two specified connections. Invoked when the user has made a request to merge the 972 * specified connections into a conference call. In response, the connection service should 973 * create an instance of {@link Conference} and pass it into {@link #addConference}. 974 * 975 * @param connection1 A connection to merge into a conference call. 976 * @param connection2 A connection to merge into a conference call. 977 */ 978 public void onConference(Connection connection1, Connection connection2) {} 979 980 /** 981 * Indicates that a remote conference has been created for existing {@link RemoteConnection}s. 982 * When this method is invoked, this {@link ConnectionService} should create its own 983 * representation of the conference call and send it to telecom using {@link #addConference}. 984 * <p> 985 * This is only relevant to {@link ConnectionService}s which are registered with 986 * {@link PhoneAccount#CAPABILITY_CONNECTION_MANAGER}. 987 * 988 * @param conference The remote conference call. 989 */ 990 public void onRemoteConferenceAdded(RemoteConference conference) {} 991 992 /** 993 * Called when an existing connection is added remotely. 994 * @param connection The existing connection which was added. 995 */ 996 public void onRemoteExistingConnectionAdded(RemoteConnection connection) {} 997 998 /** 999 * @hide 1000 */ 1001 public boolean containsConference(Conference conference) { 1002 return mIdByConference.containsKey(conference); 1003 } 1004 1005 /** {@hide} */ 1006 void addRemoteConference(RemoteConference remoteConference) { 1007 onRemoteConferenceAdded(remoteConference); 1008 } 1009 1010 /** {@hide} */ 1011 void addRemoteExistingConnection(RemoteConnection remoteConnection) { 1012 onRemoteExistingConnectionAdded(remoteConnection); 1013 } 1014 1015 private void onAccountsInitialized() { 1016 mAreAccountsInitialized = true; 1017 for (Runnable r : mPreInitializationConnectionRequests) { 1018 r.run(); 1019 } 1020 mPreInitializationConnectionRequests.clear(); 1021 } 1022 1023 /** 1024 * Adds an existing connection to the list of connections, identified by a new UUID. 1025 * 1026 * @param connection The connection. 1027 * @return The UUID of the connection (e.g. the call-id). 1028 */ 1029 private String addExistingConnectionInternal(Connection connection) { 1030 String id = UUID.randomUUID().toString(); 1031 addConnection(id, connection); 1032 return id; 1033 } 1034 1035 private void addConnection(String callId, Connection connection) { 1036 mConnectionById.put(callId, connection); 1037 mIdByConnection.put(connection, callId); 1038 connection.addConnectionListener(mConnectionListener); 1039 connection.setConnectionService(this); 1040 } 1041 1042 private void removeConnection(Connection connection) { 1043 String id = mIdByConnection.get(connection); 1044 connection.unsetConnectionService(this); 1045 connection.removeConnectionListener(mConnectionListener); 1046 mConnectionById.remove(mIdByConnection.get(connection)); 1047 mIdByConnection.remove(connection); 1048 mAdapter.removeCall(id); 1049 } 1050 1051 private String addConferenceInternal(Conference conference) { 1052 if (mIdByConference.containsKey(conference)) { 1053 Log.w(this, "Re-adding an existing conference: %s.", conference); 1054 } else if (conference != null) { 1055 String id = UUID.randomUUID().toString(); 1056 mConferenceById.put(id, conference); 1057 mIdByConference.put(conference, id); 1058 conference.addListener(mConferenceListener); 1059 return id; 1060 } 1061 1062 return null; 1063 } 1064 1065 private void removeConference(Conference conference) { 1066 if (mIdByConference.containsKey(conference)) { 1067 conference.removeListener(mConferenceListener); 1068 1069 String id = mIdByConference.get(conference); 1070 mConferenceById.remove(id); 1071 mIdByConference.remove(conference); 1072 mAdapter.removeCall(id); 1073 } 1074 } 1075 1076 private Connection findConnectionForAction(String callId, String action) { 1077 if (mConnectionById.containsKey(callId)) { 1078 return mConnectionById.get(callId); 1079 } 1080 Log.w(this, "%s - Cannot find Connection %s", action, callId); 1081 return getNullConnection(); 1082 } 1083 1084 static synchronized Connection getNullConnection() { 1085 if (sNullConnection == null) { 1086 sNullConnection = new Connection() {}; 1087 } 1088 return sNullConnection; 1089 } 1090 1091 private Conference findConferenceForAction(String conferenceId, String action) { 1092 if (mConferenceById.containsKey(conferenceId)) { 1093 return mConferenceById.get(conferenceId); 1094 } 1095 Log.w(this, "%s - Cannot find conference %s", action, conferenceId); 1096 return getNullConference(); 1097 } 1098 1099 private List<String> createConnectionIdList(List<Connection> connections) { 1100 List<String> ids = new ArrayList<>(); 1101 for (Connection c : connections) { 1102 if (mIdByConnection.containsKey(c)) { 1103 ids.add(mIdByConnection.get(c)); 1104 } 1105 } 1106 Collections.sort(ids); 1107 return ids; 1108 } 1109 1110 private Conference getNullConference() { 1111 if (sNullConference == null) { 1112 sNullConference = new Conference(null) {}; 1113 } 1114 return sNullConference; 1115 } 1116 1117 private void endAllConnections() { 1118 // Unbound from telecomm. We should end all connections and conferences. 1119 for (Connection connection : mIdByConnection.keySet()) { 1120 // only operate on top-level calls. Conference calls will be removed on their own. 1121 if (connection.getConference() == null) { 1122 connection.onDisconnect(); 1123 } 1124 } 1125 for (Conference conference : mIdByConference.keySet()) { 1126 conference.onDisconnect(); 1127 } 1128 } 1129} 1130