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