1 /* 2 * Copyright (C) 2015 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package android.telecom.cts; 18 19 import static android.telecom.cts.TestUtils.*; 20 21 import android.graphics.SurfaceTexture; 22 import android.net.Uri; 23 import android.os.Bundle; 24 import android.os.Handler; 25 import android.os.HandlerThread; 26 import android.os.Looper; 27 import android.telecom.Call; 28 import android.telecom.Connection; 29 import android.telecom.ConnectionRequest; 30 import android.telecom.DisconnectCause; 31 import android.telecom.PhoneAccountHandle; 32 import android.telecom.RemoteConnection; 33 import android.telecom.RemoteConnection.VideoProvider; 34 import android.telecom.StatusHints; 35 import android.telecom.TelecomManager; 36 import android.telecom.VideoProfile; 37 import android.view.Surface; 38 39 import java.util.ArrayList; 40 import java.util.List; 41 42 /** 43 * Extended suite of tests that use {@link CtsConnectionService} and {@link MockInCallService} to 44 * verify the functionality of Remote Connections. 45 * We make 2 connections on the {@link CtsConnectionService} & we create 2 connections on the 46 * {@link CtsRemoteConnectionService} via the {@link RemoteConnection} object. We store this 47 * corresponding RemoteConnection object on the connections to plumb the modifications on 48 * the connections in {@link CtsConnectionService} to the connections on 49 * {@link CtsRemoteConnectionService}. 50 */ 51 public class RemoteConnectionTest extends BaseRemoteTelecomTest { 52 53 MockConnection mConnection; 54 MockConnection mRemoteConnection; 55 RemoteConnection mRemoteConnectionObject; 56 57 public void testRemoteConnectionOutgoingCall() { 58 if (!mShouldTestTelecom) { 59 return; 60 } 61 addRemoteConnectionOutgoingCall(); 62 final Call call = mInCallCallbacks.getService().getLastCall(); 63 assertCallState(call, Call.STATE_DIALING); 64 65 verifyRemoteConnectionObject(mRemoteConnectionObject, mRemoteConnection); 66 67 mConnection.setActive(); 68 mRemoteConnection.setActive(); 69 70 assertCallState(call, Call.STATE_ACTIVE); 71 assertConnectionState(mConnection, Connection.STATE_ACTIVE); 72 assertRemoteConnectionState(mRemoteConnectionObject, Connection.STATE_ACTIVE); 73 assertConnectionState(mRemoteConnection, Connection.STATE_ACTIVE); 74 75 call.hold(); 76 assertCallState(call, Call.STATE_HOLDING); 77 assertConnectionState(mConnection, Connection.STATE_HOLDING); 78 assertRemoteConnectionState(mRemoteConnectionObject, Connection.STATE_HOLDING); 79 assertConnectionState(mRemoteConnection, Connection.STATE_HOLDING); 80 81 call.unhold(); 82 assertCallState(call, Call.STATE_ACTIVE); 83 assertConnectionState(mConnection, Connection.STATE_ACTIVE); 84 assertRemoteConnectionState(mRemoteConnectionObject, Connection.STATE_ACTIVE); 85 assertConnectionState(mRemoteConnection, Connection.STATE_ACTIVE); 86 87 call.disconnect(); 88 assertCallState(call, Call.STATE_DISCONNECTED); 89 assertConnectionState(mConnection, Connection.STATE_DISCONNECTED); 90 assertRemoteConnectionState(mRemoteConnectionObject, Connection.STATE_DISCONNECTED); 91 assertConnectionState(mRemoteConnection, Connection.STATE_DISCONNECTED); 92 } 93 94 public void testRemoteConnectionIncomingCallAccept() { 95 if (!mShouldTestTelecom) { 96 return; 97 } 98 addRemoteConnectionIncomingCall(); 99 final Call call = mInCallCallbacks.getService().getLastCall(); 100 assertCallState(call, Call.STATE_RINGING); 101 102 verifyRemoteConnectionObject(mRemoteConnectionObject, mRemoteConnection); 103 104 assertConnectionState(mConnection, Connection.STATE_RINGING); 105 assertRemoteConnectionState(mRemoteConnectionObject, Connection.STATE_RINGING); 106 assertConnectionState(mRemoteConnection, Connection.STATE_RINGING); 107 108 call.answer(VideoProfile.STATE_AUDIO_ONLY); 109 assertCallState(call, Call.STATE_ACTIVE); 110 assertConnectionState(mConnection, Connection.STATE_ACTIVE); 111 assertRemoteConnectionState(mRemoteConnectionObject, Connection.STATE_ACTIVE); 112 assertConnectionState(mRemoteConnection, Connection.STATE_ACTIVE); 113 } 114 115 public void testRemoteConnectionIncomingCallReject() { 116 if (!mShouldTestTelecom) { 117 return; 118 } 119 addRemoteConnectionIncomingCall(); 120 final Call call = mInCallCallbacks.getService().getLastCall(); 121 assertCallState(call, Call.STATE_RINGING); 122 123 verifyRemoteConnectionObject(mRemoteConnectionObject, mRemoteConnection); 124 125 assertConnectionState(mConnection, Connection.STATE_RINGING); 126 assertRemoteConnectionState(mRemoteConnectionObject, Connection.STATE_RINGING); 127 assertConnectionState(mRemoteConnection, Connection.STATE_RINGING); 128 129 call.reject(false, null); 130 assertCallState(call, Call.STATE_DISCONNECTED); 131 assertConnectionState(mConnection, Connection.STATE_DISCONNECTED); 132 assertRemoteConnectionState(mRemoteConnectionObject, Connection.STATE_DISCONNECTED); 133 assertConnectionState(mRemoteConnection, Connection.STATE_DISCONNECTED); 134 } 135 136 public void testRemoteConnectionDTMFTone() { 137 if (!mShouldTestTelecom) { 138 return; 139 } 140 addRemoteConnectionIncomingCall(); 141 final Call call = mInCallCallbacks.getService().getLastCall(); 142 assertCallState(call, Call.STATE_RINGING); 143 144 verifyRemoteConnectionObject(mRemoteConnectionObject, mRemoteConnection); 145 146 assertTrue(mConnection.getDtmfString().isEmpty()); 147 assertTrue(mRemoteConnection.getDtmfString().isEmpty()); 148 call.playDtmfTone('1'); 149 assertDtmfString(mConnection, "1"); 150 assertDtmfString(mRemoteConnection, "1"); 151 call.stopDtmfTone(); 152 assertDtmfString(mConnection, "1."); 153 assertDtmfString(mRemoteConnection, "1."); 154 call.playDtmfTone('3'); 155 assertDtmfString(mConnection, "1.3"); 156 assertDtmfString(mRemoteConnection, "1.3"); 157 call.stopDtmfTone(); 158 assertDtmfString(mConnection, "1.3."); 159 assertDtmfString(mRemoteConnection, "1.3."); 160 } 161 162 public void testRemoteConnectionCallbacks_StateChange() { 163 if (!mShouldTestTelecom) { 164 return; 165 } 166 167 Handler handler = setupRemoteConnectionCallbacksTest(); 168 169 final InvokeCounter callbackInvoker = 170 new InvokeCounter("testRemoteConnectionCallbacks_StateChange"); 171 RemoteConnection.Callback callback; 172 173 callback = new RemoteConnection.Callback() { 174 @Override 175 public void onStateChanged(RemoteConnection connection, int state) { 176 super.onStateChanged(connection, state); 177 callbackInvoker.invoke(connection, state); 178 } 179 }; 180 mRemoteConnectionObject.registerCallback(callback, handler); 181 mRemoteConnection.setActive(); 182 callbackInvoker.waitForCount(1, WAIT_FOR_STATE_CHANGE_TIMEOUT_MS); 183 assertEquals(mRemoteConnectionObject, callbackInvoker.getArgs(0)[0]); 184 assertEquals(Connection.STATE_ACTIVE, callbackInvoker.getArgs(0)[1]); 185 mRemoteConnectionObject.unregisterCallback(callback); 186 } 187 188 public void testRemoteConnectionCallbacks_RingbackRequest() { 189 if (!mShouldTestTelecom) { 190 return; 191 } 192 193 Handler handler = setupRemoteConnectionCallbacksTest(); 194 195 final InvokeCounter callbackInvoker = 196 new InvokeCounter("testRemoteConnectionCallbacks_RingbackRequest"); 197 RemoteConnection.Callback callback; 198 199 callback = new RemoteConnection.Callback() { 200 @Override 201 public void onRingbackRequested(RemoteConnection connection, boolean ringback) { 202 super.onRingbackRequested(connection, ringback); 203 callbackInvoker.invoke(connection, ringback); 204 } 205 }; 206 mRemoteConnectionObject.registerCallback(callback, handler); 207 mRemoteConnection.setRingbackRequested(true); 208 callbackInvoker.waitForCount(1, WAIT_FOR_STATE_CHANGE_TIMEOUT_MS); 209 assertEquals(mRemoteConnectionObject, callbackInvoker.getArgs(0)[0]); 210 assertTrue((boolean) callbackInvoker.getArgs(0)[1]); 211 mRemoteConnectionObject.unregisterCallback(callback); 212 } 213 214 public void testRemoteConnectionCallbacks_ConnectionCapabilities() { 215 if (!mShouldTestTelecom) { 216 return; 217 } 218 219 Handler handler = setupRemoteConnectionCallbacksTest(); 220 221 final InvokeCounter callbackInvoker = 222 new InvokeCounter("testRemoteConnectionCallbacks_ConnectionCapabilities"); 223 RemoteConnection.Callback callback; 224 225 callback = new RemoteConnection.Callback() { 226 @Override 227 public void onConnectionCapabilitiesChanged( 228 RemoteConnection connection, 229 int connectionCapabilities) { 230 super.onConnectionCapabilitiesChanged(connection, connectionCapabilities); 231 callbackInvoker.invoke(connection, connectionCapabilities); 232 } 233 }; 234 mRemoteConnectionObject.registerCallback(callback, handler); 235 int capabilities = mRemoteConnection.getConnectionCapabilities() | Connection.CAPABILITY_MUTE; 236 mRemoteConnection.setConnectionCapabilities(capabilities); 237 callbackInvoker.waitForCount(1, WAIT_FOR_STATE_CHANGE_TIMEOUT_MS); 238 assertEquals(mRemoteConnectionObject, callbackInvoker.getArgs(0)[0]); 239 assertEquals(capabilities, callbackInvoker.getArgs(0)[1]); 240 mRemoteConnectionObject.unregisterCallback(callback); 241 242 } 243 244 public void testRemoteConnectionCallbacks_PostDialWait() { 245 if (!mShouldTestTelecom) { 246 return; 247 } 248 249 Handler handler = setupRemoteConnectionCallbacksTest(); 250 251 final InvokeCounter callbackInvoker = 252 new InvokeCounter("testRemoteConnectionCallbacks_PostDialWait"); 253 RemoteConnection.Callback callback; 254 255 callback = new RemoteConnection.Callback() { 256 @Override 257 public void onPostDialWait(RemoteConnection connection, 258 String remainingPostDialSequence) { 259 super.onPostDialWait(connection, remainingPostDialSequence); 260 callbackInvoker.invoke(connection, remainingPostDialSequence); 261 } 262 }; 263 mRemoteConnectionObject.registerCallback(callback, handler); 264 String postDialSequence = "test"; 265 mRemoteConnection.setPostDialWait(postDialSequence); 266 callbackInvoker.waitForCount(1, WAIT_FOR_STATE_CHANGE_TIMEOUT_MS); 267 assertEquals(mRemoteConnectionObject, callbackInvoker.getArgs(0)[0]); 268 assertEquals(postDialSequence, callbackInvoker.getArgs(0)[1]); 269 mRemoteConnectionObject.unregisterCallback(callback); 270 } 271 272 public void testRemoteConnectionCallbacks_PostDialChar() { 273 if (!mShouldTestTelecom) { 274 return; 275 } 276 277 Handler handler = setupRemoteConnectionCallbacksTest(); 278 279 final InvokeCounter callbackInvoker = 280 new InvokeCounter("testRemoteConnectionCallbacks_PostDialChar"); 281 RemoteConnection.Callback callback; 282 283 callback = new RemoteConnection.Callback() { 284 @Override 285 public void onPostDialChar(RemoteConnection connection, char nextChar) { 286 super.onPostDialChar(connection, nextChar); 287 callbackInvoker.invoke(connection, nextChar); 288 } 289 }; 290 mRemoteConnectionObject.registerCallback(callback, handler); 291 char postDialChar = '3'; 292 ((Connection) mRemoteConnection).setNextPostDialChar(postDialChar); 293 callbackInvoker.waitForCount(1, WAIT_FOR_STATE_CHANGE_TIMEOUT_MS); 294 assertEquals(mRemoteConnectionObject, callbackInvoker.getArgs(0)[0]); 295 assertEquals(postDialChar, callbackInvoker.getArgs(0)[1]); 296 mRemoteConnectionObject.unregisterCallback(callback); 297 } 298 299 public void testRemoteConnectionCallbacks_VoipAudio() { 300 if (!mShouldTestTelecom) { 301 return; 302 } 303 304 Handler handler = setupRemoteConnectionCallbacksTest(); 305 306 final InvokeCounter callbackInvoker = 307 new InvokeCounter("testRemoteConnectionCallbacks_VoipAudio"); 308 RemoteConnection.Callback callback; 309 310 callback = new RemoteConnection.Callback() { 311 @Override 312 public void onVoipAudioChanged(RemoteConnection connection, boolean isVoip) { 313 super.onVoipAudioChanged(connection, isVoip); 314 callbackInvoker.invoke(connection, isVoip); 315 } 316 }; 317 mRemoteConnectionObject.registerCallback(callback, handler); 318 mRemoteConnection.setAudioModeIsVoip(true); 319 callbackInvoker.waitForCount(1, WAIT_FOR_STATE_CHANGE_TIMEOUT_MS); 320 assertEquals(mRemoteConnectionObject, callbackInvoker.getArgs(0)[0]); 321 assertTrue((boolean) callbackInvoker.getArgs(0)[1]); 322 mRemoteConnectionObject.unregisterCallback(callback); 323 } 324 325 public void testRemoteConnectionCallbacks_StatusHints() { 326 if (!mShouldTestTelecom) { 327 return; 328 } 329 330 Handler handler = setupRemoteConnectionCallbacksTest(); 331 332 final InvokeCounter callbackInvoker = 333 new InvokeCounter("testRemoteConnectionCallbacks_StatusHints"); 334 RemoteConnection.Callback callback; 335 336 callback = new RemoteConnection.Callback() { 337 @Override 338 public void onStatusHintsChanged(RemoteConnection connection, StatusHints statusHints) { 339 super.onStatusHintsChanged(connection, statusHints); 340 callbackInvoker.invoke(connection, statusHints); 341 } 342 }; 343 mRemoteConnectionObject.registerCallback(callback, handler); 344 StatusHints hints = new StatusHints("test", null, null); 345 mRemoteConnection.setStatusHints(hints); 346 callbackInvoker.waitForCount(1, WAIT_FOR_STATE_CHANGE_TIMEOUT_MS); 347 assertEquals(mRemoteConnectionObject, callbackInvoker.getArgs(0)[0]); 348 assertEquals(hints, callbackInvoker.getArgs(0)[1]); 349 mRemoteConnectionObject.unregisterCallback(callback); 350 } 351 352 public void testRemoteConnectionCallbacks_AddressChange() { 353 if (!mShouldTestTelecom) { 354 return; 355 } 356 357 Handler handler = setupRemoteConnectionCallbacksTest(); 358 359 final InvokeCounter callbackInvoker = 360 new InvokeCounter("testRemoteConnectionCallbacks_AddressChange"); 361 RemoteConnection.Callback callback; 362 363 callback = new RemoteConnection.Callback() { 364 @Override 365 public void onAddressChanged(RemoteConnection connection, Uri address, 366 int presentation) { 367 super.onAddressChanged(connection, address, presentation); 368 callbackInvoker.invoke(connection, address, presentation); 369 } 370 }; 371 mRemoteConnectionObject.registerCallback(callback, handler); 372 Uri address = Uri.parse("tel:555"); 373 mRemoteConnection.setAddress(address, TelecomManager.PRESENTATION_ALLOWED); 374 callbackInvoker.waitForCount(1, WAIT_FOR_STATE_CHANGE_TIMEOUT_MS); 375 assertEquals(mRemoteConnectionObject, callbackInvoker.getArgs(0)[0]); 376 assertEquals(address, callbackInvoker.getArgs(0)[1]); 377 assertEquals(TelecomManager.PRESENTATION_ALLOWED, callbackInvoker.getArgs(0)[2]); 378 mRemoteConnectionObject.unregisterCallback(callback); 379 } 380 381 public void testRemoteConnectionCallbacks_CallerDisplayName() { 382 if (!mShouldTestTelecom) { 383 return; 384 } 385 386 Handler handler = setupRemoteConnectionCallbacksTest(); 387 388 final InvokeCounter callbackInvoker = 389 new InvokeCounter("testRemoteConnectionCallbacks_CallerDisplayName"); 390 RemoteConnection.Callback callback; 391 392 callback = new RemoteConnection.Callback() { 393 @Override 394 public void onCallerDisplayNameChanged( 395 RemoteConnection connection, String callerDisplayName, int presentation) { 396 super.onCallerDisplayNameChanged(connection, callerDisplayName, presentation); 397 callbackInvoker.invoke(connection, callerDisplayName, presentation); 398 } 399 }; 400 mRemoteConnectionObject.registerCallback(callback, handler); 401 String callerDisplayName = "test"; 402 mRemoteConnection.setCallerDisplayName(callerDisplayName, TelecomManager.PRESENTATION_ALLOWED); 403 callbackInvoker.waitForCount(1, WAIT_FOR_STATE_CHANGE_TIMEOUT_MS); 404 assertEquals(mRemoteConnectionObject, callbackInvoker.getArgs(0)[0]); 405 assertEquals(callerDisplayName, callbackInvoker.getArgs(0)[1]); 406 assertEquals(TelecomManager.PRESENTATION_ALLOWED, callbackInvoker.getArgs(0)[2]); 407 mRemoteConnectionObject.unregisterCallback(callback); 408 } 409 410 public void testRemoteConnectionCallbacks_VideoState() { 411 if (!mShouldTestTelecom) { 412 return; 413 } 414 415 Handler handler = setupRemoteConnectionCallbacksTest(); 416 417 final InvokeCounter callbackInvoker = 418 new InvokeCounter("testRemoteConnectionCallbacks_VideoState"); 419 RemoteConnection.Callback callback; 420 421 callback = new RemoteConnection.Callback() { 422 @Override 423 public void onVideoStateChanged(RemoteConnection connection, int videoState) { 424 super.onVideoStateChanged(connection, videoState); 425 callbackInvoker.invoke(connection, videoState); 426 } 427 }; 428 mRemoteConnectionObject.registerCallback(callback, handler); 429 mRemoteConnection.setVideoState(VideoProfile.STATE_BIDIRECTIONAL); 430 callbackInvoker.waitForCount(1, WAIT_FOR_STATE_CHANGE_TIMEOUT_MS); 431 assertEquals(mRemoteConnectionObject, callbackInvoker.getArgs(0)[0]); 432 assertEquals(VideoProfile.STATE_BIDIRECTIONAL, callbackInvoker.getArgs(0)[1]); 433 mRemoteConnectionObject.unregisterCallback(callback); 434 } 435 436 public void testRemoteConnectionCallbacks_ConferenceableConnections() { 437 if (!mShouldTestTelecom) { 438 return; 439 } 440 441 Handler handler = setupRemoteConnectionCallbacksTest(); 442 443 final InvokeCounter callbackInvoker = 444 new InvokeCounter("testRemoteConnectionCallbacks_ConferenceableConnections"); 445 RemoteConnection.Callback callback; 446 447 callback = new RemoteConnection.Callback() { 448 @Override 449 public void onConferenceableConnectionsChanged( 450 RemoteConnection connection, 451 List<RemoteConnection> conferenceableConnections) { 452 super.onConferenceableConnectionsChanged(connection, conferenceableConnections); 453 callbackInvoker.invoke(connection, conferenceableConnections); 454 } 455 }; 456 mRemoteConnectionObject.registerCallback(callback, handler); 457 //Make the existing call active to add a new call 458 final Call call = mInCallCallbacks.getService().getLastCall(); 459 mConnection.setActive(); 460 mRemoteConnection.setActive(); 461 assertCallState(call, Call.STATE_ACTIVE); 462 placeAndVerifyCall(); 463 RemoteConnection newRemoteConnectionObject = 464 verifyConnectionForOutgoingCall(1).getRemoteConnection(); 465 MockConnection newConnection = verifyConnectionForOutgoingCallOnRemoteCS(1); 466 ArrayList<Connection> confList = new ArrayList<>(); 467 confList.add(newConnection); 468 mRemoteConnection.setConferenceableConnections(confList); 469 callbackInvoker.waitForCount(1, WAIT_FOR_STATE_CHANGE_TIMEOUT_MS); 470 assertEquals(mRemoteConnectionObject, callbackInvoker.getArgs(0)[0]); 471 //assertTrue(((List<RemoteConnection>)callbackInvoker.getArgs(0)[1]).contains( 472 //newRemoteConnectionObject)); No "equals" method in RemoteConnection 473 mRemoteConnectionObject.unregisterCallback(callback); 474 } 475 476 public void testRemoteConnectionCallbacks_VideoProvider() { 477 if (!mShouldTestTelecom) { 478 return; 479 } 480 481 Handler handler = setupRemoteConnectionCallbacksTest(); 482 483 final InvokeCounter callbackInvoker = 484 new InvokeCounter("testRemoteConnectionCallbacks_VideoProvider"); 485 RemoteConnection.Callback callback; 486 487 callback = new RemoteConnection.Callback() { 488 @Override 489 public void onVideoProviderChanged( 490 RemoteConnection connection, VideoProvider videoProvider) { 491 super.onVideoProviderChanged(connection, videoProvider); 492 callbackInvoker.invoke(connection, videoProvider); 493 } 494 }; 495 mRemoteConnectionObject.registerCallback(callback, handler); 496 mRemoteConnection.createMockVideoProvider(); 497 MockVideoProvider mockVideoProvider = mRemoteConnection.getMockVideoProvider(); 498 mRemoteConnection.setVideoProvider(mockVideoProvider); 499 callbackInvoker.waitForCount(1, WAIT_FOR_STATE_CHANGE_TIMEOUT_MS); 500 assertEquals(mRemoteConnectionObject, callbackInvoker.getArgs(0)[0]); 501 mRemoteConnectionObject.unregisterCallback(callback); 502 } 503 504 public void testRemoteConnectionCallbacks_Extras() { 505 if (!mShouldTestTelecom) { 506 return; 507 } 508 509 Handler handler = setupRemoteConnectionCallbacksTest(); 510 511 final InvokeCounter callbackInvoker = 512 new InvokeCounter("testRemoteConnectionCallbacks_Extras"); 513 RemoteConnection.Callback callback; 514 515 callback = new RemoteConnection.Callback() { 516 @Override 517 public void onExtrasChanged(RemoteConnection connection, Bundle extras) { 518 super.onExtrasChanged(connection, extras); 519 callbackInvoker.invoke(connection, extras); 520 } 521 }; 522 mRemoteConnectionObject.registerCallback(callback, handler); 523 Bundle extras = new Bundle(); 524 extras.putString(TelecomManager.EXTRA_CALL_DISCONNECT_MESSAGE, "Test"); 525 mRemoteConnection.setExtras(extras); 526 callbackInvoker.waitForCount(1, WAIT_FOR_STATE_CHANGE_TIMEOUT_MS); 527 assertEquals(mRemoteConnectionObject, callbackInvoker.getArgs(0)[0]); 528 assertEquals(extras, callbackInvoker.getArgs(0)[1]); 529 mRemoteConnectionObject.unregisterCallback(callback); 530 531 } 532 533 public void testRemoteConnectionCallbacks_Disconnect() { 534 if (!mShouldTestTelecom) { 535 return; 536 } 537 538 Handler handler = setupRemoteConnectionCallbacksTest(); 539 540 final InvokeCounter callbackInvoker = 541 new InvokeCounter("testRemoteConnectionCallbacks_Disconnect"); 542 RemoteConnection.Callback callback; 543 544 callback = new RemoteConnection.Callback() { 545 @Override 546 public void onDisconnected( 547 RemoteConnection connection, 548 DisconnectCause disconnectCause) { 549 super.onDisconnected(connection, disconnectCause); 550 callbackInvoker.invoke(connection, disconnectCause); 551 } 552 }; 553 mRemoteConnectionObject.registerCallback(callback, handler); 554 DisconnectCause cause = new DisconnectCause(DisconnectCause.LOCAL); 555 mRemoteConnection.setDisconnected(cause); 556 callbackInvoker.waitForCount(1, WAIT_FOR_STATE_CHANGE_TIMEOUT_MS); 557 assertEquals(mRemoteConnectionObject, callbackInvoker.getArgs(0)[0]); 558 assertEquals(cause, callbackInvoker.getArgs(0)[1]); 559 mRemoteConnectionObject.unregisterCallback(callback); 560 } 561 562 public void testRemoteConnectionCallbacks_Destroy() { 563 if (!mShouldTestTelecom) { 564 return; 565 } 566 567 Handler handler = setupRemoteConnectionCallbacksTest(); 568 569 final InvokeCounter callbackInvoker = 570 new InvokeCounter("testRemoteConnectionCallbacks_Destroy"); 571 RemoteConnection.Callback callback; 572 573 callback = new RemoteConnection.Callback() { 574 @Override 575 public void onDestroyed(RemoteConnection connection) { 576 super.onDestroyed(connection); 577 callbackInvoker.invoke(connection); 578 } 579 }; 580 mRemoteConnectionObject.registerCallback(callback, handler); 581 mRemoteConnection.destroy(); 582 callbackInvoker.waitForCount(1, WAIT_FOR_STATE_CHANGE_TIMEOUT_MS); 583 assertEquals(mRemoteConnectionObject, callbackInvoker.getArgs(0)[0]); 584 mRemoteConnectionObject.unregisterCallback(callback); 585 } 586 587 public void testRemoteConnectionVideoCallbacks_SessionModify() { 588 if (!mShouldTestTelecom) { 589 return; 590 } 591 592 setupRemoteConnectionVideoCallbacksTest(); 593 594 final InvokeCounter callbackInvoker = 595 new InvokeCounter("testRemoteConnectionVideoCallbacks_SessionModify"); 596 final VideoProvider remoteVideoProvider = mRemoteConnectionObject.getVideoProvider(); 597 final MockVideoProvider mockVideoProvider = mRemoteConnection.getMockVideoProvider(); 598 RemoteConnection.VideoProvider.Callback videoCallback; 599 600 videoCallback = new RemoteConnection.VideoProvider.Callback() { 601 @Override 602 public void onSessionModifyRequestReceived( 603 VideoProvider videoProvider, 604 VideoProfile videoProfile) { 605 super.onSessionModifyRequestReceived(videoProvider, videoProfile); 606 callbackInvoker.invoke(videoProvider, videoProfile); 607 } 608 609 @Override 610 public void onSessionModifyResponseReceived( 611 VideoProvider videoProvider, 612 int status, 613 VideoProfile requestedProfile, 614 VideoProfile responseProfile) { 615 super.onSessionModifyResponseReceived(videoProvider, status, requestedProfile, 616 responseProfile); 617 callbackInvoker.invoke(videoProvider, status, requestedProfile, responseProfile); 618 } 619 }; 620 remoteVideoProvider.registerCallback(videoCallback); 621 VideoProfile videoProfile = new VideoProfile(VideoProfile.STATE_BIDIRECTIONAL); 622 mockVideoProvider.sendMockSessionModifyRequest(videoProfile); 623 callbackInvoker.waitForCount(1, WAIT_FOR_STATE_CHANGE_TIMEOUT_MS); 624 assertEquals(remoteVideoProvider, callbackInvoker.getArgs(0)[0]); 625 assertEquals(videoProfile, callbackInvoker.getArgs(0)[1]); 626 remoteVideoProvider.unregisterCallback(videoCallback); 627 } 628 629 public void testRemoteConnectionVideoCallbacks_SessionEvent() { 630 if (!mShouldTestTelecom) { 631 return; 632 } 633 634 setupRemoteConnectionVideoCallbacksTest(); 635 636 final InvokeCounter callbackInvoker = 637 new InvokeCounter("testRemoteConnectionVideoCallbacks_SessionEvent"); 638 final VideoProvider remoteVideoProvider = mRemoteConnectionObject.getVideoProvider(); 639 final MockVideoProvider mockVideoProvider = mRemoteConnection.getMockVideoProvider(); 640 RemoteConnection.VideoProvider.Callback videoCallback; 641 642 videoCallback = new RemoteConnection.VideoProvider.Callback() { 643 @Override 644 public void onCallSessionEvent(VideoProvider videoProvider, int event) { 645 super.onCallSessionEvent(videoProvider, event); 646 callbackInvoker.invoke(videoProvider, event); 647 } 648 }; 649 remoteVideoProvider.registerCallback(videoCallback); 650 mockVideoProvider.handleCallSessionEvent(Connection.VideoProvider.SESSION_EVENT_RX_PAUSE); 651 callbackInvoker.waitForCount(1, WAIT_FOR_STATE_CHANGE_TIMEOUT_MS); 652 assertEquals(remoteVideoProvider, callbackInvoker.getArgs(0)[0]); 653 assertEquals(Connection.VideoProvider.SESSION_EVENT_RX_PAUSE, callbackInvoker.getArgs(0)[1]); 654 remoteVideoProvider.unregisterCallback(videoCallback); 655 } 656 657 public void testRemoteConnectionVideoCallbacks_PeerDimensions() { 658 if (!mShouldTestTelecom) { 659 return; 660 } 661 662 setupRemoteConnectionVideoCallbacksTest(); 663 664 final InvokeCounter callbackInvoker = 665 new InvokeCounter("testRemoteConnectionVideoCallbacks_PeerDimensions"); 666 final VideoProvider remoteVideoProvider = mRemoteConnectionObject.getVideoProvider(); 667 final MockVideoProvider mockVideoProvider = mRemoteConnection.getMockVideoProvider(); 668 RemoteConnection.VideoProvider.Callback videoCallback; 669 670 videoCallback = new RemoteConnection.VideoProvider.Callback() { 671 @Override 672 public void onPeerDimensionsChanged(VideoProvider videoProvider, int width, 673 int height) { 674 super.onPeerDimensionsChanged(videoProvider, width, height); 675 callbackInvoker.invoke(videoProvider, width, height); 676 } 677 }; 678 remoteVideoProvider.registerCallback(videoCallback); 679 final int width = 100, heigth = 20; 680 mockVideoProvider.changePeerDimensions(width, heigth); 681 callbackInvoker.waitForCount(1, WAIT_FOR_STATE_CHANGE_TIMEOUT_MS); 682 assertEquals(remoteVideoProvider, callbackInvoker.getArgs(0)[0]); 683 assertEquals(width, callbackInvoker.getArgs(0)[1]); 684 assertEquals(heigth, callbackInvoker.getArgs(0)[2]); 685 remoteVideoProvider.unregisterCallback(videoCallback); 686 } 687 688 public void testRemoteConnectionVideoCallbacks_CallDataUsage() { 689 if (!mShouldTestTelecom) { 690 return; 691 } 692 693 setupRemoteConnectionVideoCallbacksTest(); 694 695 final InvokeCounter callbackInvoker = 696 new InvokeCounter("testRemoteConnectionVideoCallbacks_CallDataUsage"); 697 final VideoProvider remoteVideoProvider = mRemoteConnectionObject.getVideoProvider(); 698 final MockVideoProvider mockVideoProvider = mRemoteConnection.getMockVideoProvider(); 699 RemoteConnection.VideoProvider.Callback videoCallback; 700 701 videoCallback = new RemoteConnection.VideoProvider.Callback() { 702 @Override 703 public void onCallDataUsageChanged(VideoProvider videoProvider, long dataUsage) { 704 super.onCallDataUsageChanged(videoProvider, dataUsage); 705 callbackInvoker.invoke(videoProvider, dataUsage); 706 } 707 }; 708 remoteVideoProvider.registerCallback(videoCallback); 709 long callDataUsage = 10000; 710 mockVideoProvider.setCallDataUsage(callDataUsage); 711 callbackInvoker.waitForCount(1, WAIT_FOR_STATE_CHANGE_TIMEOUT_MS); 712 assertEquals(remoteVideoProvider, callbackInvoker.getArgs(0)[0]); 713 assertEquals(callDataUsage, callbackInvoker.getArgs(0)[1]); 714 remoteVideoProvider.unregisterCallback(videoCallback); 715 } 716 717 public void testRemoteConnectionVideoCallbacks_CameraCapabilities() { 718 if (!mShouldTestTelecom) { 719 return; 720 } 721 722 setupRemoteConnectionVideoCallbacksTest(); 723 724 final InvokeCounter callbackInvoker = 725 new InvokeCounter("testRemoteConnectionVideoCallbacks_CameraCapabilities"); 726 final VideoProvider remoteVideoProvider = mRemoteConnectionObject.getVideoProvider(); 727 final MockVideoProvider mockVideoProvider = mRemoteConnection.getMockVideoProvider(); 728 RemoteConnection.VideoProvider.Callback videoCallback; 729 730 videoCallback = new RemoteConnection.VideoProvider.Callback() { 731 @Override 732 public void onCameraCapabilitiesChanged( 733 VideoProvider videoProvider, 734 VideoProfile.CameraCapabilities cameraCapabilities) { 735 super.onCameraCapabilitiesChanged(videoProvider, cameraCapabilities); 736 callbackInvoker.invoke(videoProvider, cameraCapabilities); 737 } 738 }; 739 remoteVideoProvider.registerCallback(videoCallback); 740 VideoProfile.CameraCapabilities capabilities = new VideoProfile.CameraCapabilities(100, 200); 741 mockVideoProvider.changeCameraCapabilities(capabilities); 742 callbackInvoker.waitForCount(1, WAIT_FOR_STATE_CHANGE_TIMEOUT_MS); 743 assertEquals(remoteVideoProvider, callbackInvoker.getArgs(0)[0]); 744 assertEquals(capabilities, callbackInvoker.getArgs(0)[1]); 745 remoteVideoProvider.unregisterCallback(videoCallback); 746 } 747 748 public void testRemoteConnectionVideoCallbacks_VideoQuality() { 749 if (!mShouldTestTelecom) { 750 return; 751 } 752 753 setupRemoteConnectionVideoCallbacksTest(); 754 755 final InvokeCounter callbackInvoker = 756 new InvokeCounter("testRemoteConnectionVideoCallbacks_VideoQuality"); 757 final VideoProvider remoteVideoProvider = mRemoteConnectionObject.getVideoProvider(); 758 final MockVideoProvider mockVideoProvider = mRemoteConnection.getMockVideoProvider(); 759 RemoteConnection.VideoProvider.Callback videoCallback; 760 761 videoCallback = new RemoteConnection.VideoProvider.Callback() { 762 @Override 763 public void onVideoQualityChanged(VideoProvider videoProvider, int videoQuality) { 764 super.onVideoQualityChanged(videoProvider, videoQuality); 765 callbackInvoker.invoke(videoProvider, videoQuality); 766 } 767 }; 768 remoteVideoProvider.registerCallback(videoCallback); 769 final int videoQuality = 10; 770 mockVideoProvider.changeVideoQuality(videoQuality); 771 callbackInvoker.waitForCount(1, WAIT_FOR_STATE_CHANGE_TIMEOUT_MS); 772 assertEquals(remoteVideoProvider, callbackInvoker.getArgs(0)[0]); 773 assertEquals(videoQuality, callbackInvoker.getArgs(0)[1]); 774 remoteVideoProvider.unregisterCallback(videoCallback); 775 } 776 777 public void testRemoteConnectionVideo_RequestCallDataUsage() { 778 if (!mShouldTestTelecom) { 779 return; 780 } 781 782 final long callDataUsage = 10000; 783 final InvokeCounter callbackInvoker = 784 new InvokeCounter("testRemoteConnectionVideo_RequestCallDataUsage"); 785 final MockVideoProvider mockVideoProvider = new MockVideoProvider(mRemoteConnection) { 786 @Override 787 public void onRequestConnectionDataUsage() { 788 callbackInvoker.invoke(); 789 super.setCallDataUsage(callDataUsage); 790 } 791 }; 792 setupRemoteConnectionVideoTest(mockVideoProvider); 793 794 final VideoProvider remoteVideoProvider = mRemoteConnectionObject.getVideoProvider(); 795 RemoteConnection.VideoProvider.Callback videoCallback; 796 797 videoCallback = new RemoteConnection.VideoProvider.Callback() { 798 @Override 799 public void onCallDataUsageChanged(VideoProvider videoProvider, long dataUsage) { 800 super.onCallDataUsageChanged(videoProvider, dataUsage); 801 callbackInvoker.invoke(videoProvider, dataUsage); 802 } 803 }; 804 remoteVideoProvider.registerCallback(videoCallback); 805 remoteVideoProvider.requestCallDataUsage(); 806 callbackInvoker.waitForCount(2, WAIT_FOR_STATE_CHANGE_TIMEOUT_MS); 807 assertEquals(remoteVideoProvider, callbackInvoker.getArgs(1)[0]); 808 assertEquals(callDataUsage, callbackInvoker.getArgs(1)[1]); 809 remoteVideoProvider.unregisterCallback(videoCallback); 810 } 811 812 public void testRemoteConnectionVideo_RequestCameraCapabilities() { 813 if (!mShouldTestTelecom) { 814 return; 815 } 816 817 final VideoProfile.CameraCapabilities capabilities = 818 new VideoProfile.CameraCapabilities(100, 200); 819 final InvokeCounter callbackInvoker = 820 new InvokeCounter("testRemoteConnectionVideo_RequestCameraCapabilities"); 821 final MockVideoProvider mockVideoProvider = new MockVideoProvider(mRemoteConnection) { 822 @Override 823 public void onRequestCameraCapabilities() { 824 callbackInvoker.invoke(); 825 super.changeCameraCapabilities(capabilities); 826 } 827 }; 828 setupRemoteConnectionVideoTest(mockVideoProvider); 829 830 final VideoProvider remoteVideoProvider = mRemoteConnectionObject.getVideoProvider(); 831 RemoteConnection.VideoProvider.Callback videoCallback; 832 833 videoCallback = new RemoteConnection.VideoProvider.Callback() { 834 @Override 835 public void onCameraCapabilitiesChanged( 836 VideoProvider videoProvider, 837 VideoProfile.CameraCapabilities cameraCapabilities) { 838 super.onCameraCapabilitiesChanged(videoProvider, cameraCapabilities); 839 callbackInvoker.invoke(videoProvider, cameraCapabilities); 840 } 841 }; 842 remoteVideoProvider.registerCallback(videoCallback); 843 remoteVideoProvider.requestCameraCapabilities(); 844 callbackInvoker.waitForCount(2, WAIT_FOR_STATE_CHANGE_TIMEOUT_MS); 845 assertEquals(remoteVideoProvider, callbackInvoker.getArgs(1)[0]); 846 assertEquals(capabilities, callbackInvoker.getArgs(1)[1]); 847 remoteVideoProvider.unregisterCallback(videoCallback); 848 } 849 850 public void testRemoteConnectionVideo_SendSessionModifyRequest() { 851 if (!mShouldTestTelecom) { 852 return; 853 } 854 855 VideoProfile fromVideoProfile = new VideoProfile(VideoProfile.STATE_AUDIO_ONLY); 856 VideoProfile toVideoProfile = new VideoProfile(VideoProfile.STATE_BIDIRECTIONAL); 857 final InvokeCounter callbackInvoker = 858 new InvokeCounter("testRemoteConnectionVideo_SendSessionModifyRequest"); 859 final MockVideoProvider mockVideoProvider = new MockVideoProvider(mRemoteConnection) { 860 @Override 861 public void onSendSessionModifyRequest(VideoProfile fromProfile, 862 VideoProfile toProfile) { 863 callbackInvoker.invoke(fromProfile, toProfile); 864 super.receiveSessionModifyRequest(toProfile); 865 } 866 }; 867 setupRemoteConnectionVideoTest(mockVideoProvider); 868 869 final VideoProvider remoteVideoProvider = mRemoteConnectionObject.getVideoProvider(); 870 RemoteConnection.VideoProvider.Callback videoCallback; 871 872 videoCallback = new RemoteConnection.VideoProvider.Callback() { 873 @Override 874 public void onSessionModifyRequestReceived( 875 VideoProvider videoProvider, 876 VideoProfile videoProfile) { 877 super.onSessionModifyRequestReceived(videoProvider, videoProfile); 878 callbackInvoker.invoke(videoProvider, videoProfile); 879 } 880 }; 881 remoteVideoProvider.registerCallback(videoCallback); 882 remoteVideoProvider.sendSessionModifyRequest(fromVideoProfile, toVideoProfile); 883 callbackInvoker.waitForCount(2, WAIT_FOR_STATE_CHANGE_TIMEOUT_MS); 884 assertEquals(fromVideoProfile, callbackInvoker.getArgs(0)[0]); 885 assertEquals(toVideoProfile, callbackInvoker.getArgs(0)[1]); 886 assertEquals(remoteVideoProvider, callbackInvoker.getArgs(1)[0]); 887 assertEquals(toVideoProfile, callbackInvoker.getArgs(1)[1]); 888 remoteVideoProvider.unregisterCallback(videoCallback); 889 } 890 891 public void testRemoteConnectionVideo_SendSessionModifyResponse() { 892 if (!mShouldTestTelecom) { 893 return; 894 } 895 896 VideoProfile toVideoProfile = new VideoProfile(VideoProfile.STATE_BIDIRECTIONAL); 897 final InvokeCounter callbackInvoker = 898 new InvokeCounter("testRemoteConnectionVideo_SendSessionModifyResponse"); 899 final MockVideoProvider mockVideoProvider = new MockVideoProvider(mRemoteConnection) { 900 @Override 901 public void onSendSessionModifyResponse(VideoProfile responseProfile) { 902 callbackInvoker.invoke(responseProfile); 903 super.receiveSessionModifyResponse( 904 Connection.VideoProvider.SESSION_MODIFY_REQUEST_SUCCESS, 905 responseProfile, responseProfile); 906 } 907 }; 908 setupRemoteConnectionVideoTest(mockVideoProvider); 909 910 final VideoProvider remoteVideoProvider = mRemoteConnectionObject.getVideoProvider(); 911 RemoteConnection.VideoProvider.Callback videoCallback; 912 913 videoCallback = new RemoteConnection.VideoProvider.Callback() { 914 @Override 915 public void onSessionModifyResponseReceived( 916 VideoProvider videoProvider, 917 int status, 918 VideoProfile requestedProfile, 919 VideoProfile responseProfile) { 920 super.onSessionModifyResponseReceived(videoProvider, status, requestedProfile, 921 responseProfile); 922 callbackInvoker.invoke(videoProvider, status, requestedProfile, responseProfile); 923 } 924 }; 925 remoteVideoProvider.registerCallback(videoCallback); 926 remoteVideoProvider.sendSessionModifyResponse(toVideoProfile); 927 callbackInvoker.waitForCount(2, WAIT_FOR_STATE_CHANGE_TIMEOUT_MS); 928 assertEquals(toVideoProfile, callbackInvoker.getArgs(0)[0]); 929 assertEquals(remoteVideoProvider, callbackInvoker.getArgs(1)[0]); 930 assertEquals(toVideoProfile, callbackInvoker.getArgs(1)[2]); 931 assertEquals(Connection.VideoProvider.SESSION_MODIFY_REQUEST_SUCCESS, 932 callbackInvoker.getArgs(1)[1]); 933 assertEquals(toVideoProfile, callbackInvoker.getArgs(1)[3]); 934 remoteVideoProvider.unregisterCallback(videoCallback); 935 } 936 937 public void testRemoteConnectionVideo_SetCamera() { 938 if (!mShouldTestTelecom) { 939 return; 940 } 941 942 final String newCameraId = "5"; 943 final VideoProfile.CameraCapabilities capabilities = 944 new VideoProfile.CameraCapabilities(100, 200); 945 final InvokeCounter callbackInvoker = 946 new InvokeCounter("testRemoteConnectionVideo_SetCamera"); 947 final MockVideoProvider mockVideoProvider = new MockVideoProvider(mRemoteConnection) { 948 @Override 949 public void onSetCamera(String cameraId) { 950 callbackInvoker.invoke(cameraId); 951 super.changeCameraCapabilities(capabilities); 952 } 953 }; 954 setupRemoteConnectionVideoTest(mockVideoProvider); 955 956 final VideoProvider remoteVideoProvider = mRemoteConnectionObject.getVideoProvider(); 957 RemoteConnection.VideoProvider.Callback videoCallback; 958 959 videoCallback = new RemoteConnection.VideoProvider.Callback() { 960 @Override 961 public void onCameraCapabilitiesChanged( 962 VideoProvider videoProvider, 963 VideoProfile.CameraCapabilities cameraCapabilities) { 964 super.onCameraCapabilitiesChanged(videoProvider, cameraCapabilities); 965 callbackInvoker.invoke(videoProvider, cameraCapabilities); 966 } 967 }; 968 remoteVideoProvider.registerCallback(videoCallback); 969 remoteVideoProvider.setCamera(newCameraId); 970 callbackInvoker.waitForCount(2, WAIT_FOR_STATE_CHANGE_TIMEOUT_MS); 971 assertEquals(newCameraId, callbackInvoker.getArgs(0)[0]); 972 assertEquals(remoteVideoProvider, callbackInvoker.getArgs(1)[0]); 973 assertEquals(capabilities, callbackInvoker.getArgs(1)[1]); 974 remoteVideoProvider.unregisterCallback(videoCallback); 975 } 976 977 public void testRemoteConnectionVideo_SetDeviceOrientation() { 978 if (!mShouldTestTelecom) { 979 return; 980 } 981 982 final int newRotation = 5; 983 final InvokeCounter callbackInvoker = 984 new InvokeCounter("testRemoteConnectionVideo_SetDeviceOrientation"); 985 final MockVideoProvider mockVideoProvider = new MockVideoProvider(mRemoteConnection) { 986 @Override 987 public void onSetDeviceOrientation(int rotation) { 988 callbackInvoker.invoke(rotation); 989 } 990 }; 991 setupRemoteConnectionVideoTest(mockVideoProvider); 992 993 final VideoProvider remoteVideoProvider = mRemoteConnectionObject.getVideoProvider(); 994 995 remoteVideoProvider.setDeviceOrientation(newRotation); 996 callbackInvoker.waitForCount(1, WAIT_FOR_STATE_CHANGE_TIMEOUT_MS); 997 assertEquals(newRotation, callbackInvoker.getArgs(0)[0]); 998 } 999 1000 public void testRemoteConnectionVideo_SetDisplaySurface() { 1001 if (!mShouldTestTelecom) { 1002 return; 1003 } 1004 1005 final Surface newSurface = new Surface(new SurfaceTexture(1)); 1006 final InvokeCounter callbackInvoker = 1007 new InvokeCounter("testRemoteConnectionVideo_SetDisplaySurface"); 1008 final MockVideoProvider mockVideoProvider = new MockVideoProvider(mRemoteConnection) { 1009 @Override 1010 public void onSetDisplaySurface(Surface surface) { 1011 callbackInvoker.invoke(surface); 1012 } 1013 }; 1014 setupRemoteConnectionVideoTest(mockVideoProvider); 1015 1016 final VideoProvider remoteVideoProvider = mRemoteConnectionObject.getVideoProvider(); 1017 1018 remoteVideoProvider.setDisplaySurface(newSurface); 1019 callbackInvoker.waitForCount(1, WAIT_FOR_STATE_CHANGE_TIMEOUT_MS); 1020 assertEquals(newSurface, callbackInvoker.getArgs(0)[0]); 1021 } 1022 1023 public void testRemoteConnectionVideo_SetPauseImage() { 1024 if (!mShouldTestTelecom) { 1025 return; 1026 } 1027 1028 final Uri newUri = Uri.parse("content://"); 1029 final InvokeCounter callbackInvoker = 1030 new InvokeCounter("testRemoteConnectionVideo_SetPauseImage"); 1031 final MockVideoProvider mockVideoProvider = new MockVideoProvider(mRemoteConnection) { 1032 @Override 1033 public void onSetPauseImage(Uri uri) { 1034 callbackInvoker.invoke(uri); 1035 } 1036 }; 1037 setupRemoteConnectionVideoTest(mockVideoProvider); 1038 1039 final VideoProvider remoteVideoProvider = mRemoteConnectionObject.getVideoProvider(); 1040 1041 remoteVideoProvider.setPauseImage(newUri); 1042 callbackInvoker.waitForCount(1, WAIT_FOR_STATE_CHANGE_TIMEOUT_MS); 1043 assertEquals(newUri, callbackInvoker.getArgs(0)[0]); 1044 } 1045 1046 public void testRemoteConnectionVideo_SetPreviewSurface() { 1047 if (!mShouldTestTelecom) { 1048 return; 1049 } 1050 1051 final Surface newSurface = new Surface(new SurfaceTexture(1)); 1052 final InvokeCounter callbackInvoker = 1053 new InvokeCounter("testRemoteConnectionVideo_SetPreviewSurface"); 1054 final MockVideoProvider mockVideoProvider = new MockVideoProvider(mRemoteConnection) { 1055 @Override 1056 public void onSetPreviewSurface(Surface surface) { 1057 callbackInvoker.invoke(surface); 1058 } 1059 }; 1060 setupRemoteConnectionVideoTest(mockVideoProvider); 1061 1062 final VideoProvider remoteVideoProvider = mRemoteConnectionObject.getVideoProvider(); 1063 1064 remoteVideoProvider.setPreviewSurface(newSurface); 1065 callbackInvoker.waitForCount(1, WAIT_FOR_STATE_CHANGE_TIMEOUT_MS); 1066 assertEquals(newSurface, callbackInvoker.getArgs(0)[0]); 1067 } 1068 1069 public void testRemoteConnectionVideo_SetZoom() { 1070 if (!mShouldTestTelecom) { 1071 return; 1072 } 1073 1074 final float newZoom = 1.0f; 1075 final InvokeCounter callbackInvoker = 1076 new InvokeCounter("testRemoteConnectionVideo_SetPreviewSurface"); 1077 final MockVideoProvider mockVideoProvider = new MockVideoProvider(mRemoteConnection) { 1078 @Override 1079 public void onSetZoom(float value) { 1080 callbackInvoker.invoke(value); 1081 } 1082 }; 1083 setupRemoteConnectionVideoTest(mockVideoProvider); 1084 1085 final VideoProvider remoteVideoProvider = mRemoteConnectionObject.getVideoProvider(); 1086 1087 remoteVideoProvider.setZoom(newZoom); 1088 callbackInvoker.waitForCount(1, WAIT_FOR_STATE_CHANGE_TIMEOUT_MS); 1089 assertEquals(newZoom, callbackInvoker.getArgs(0)[0]); 1090 } 1091 1092 private void verifyRemoteConnectionObject(RemoteConnection remoteConnection, 1093 Connection connection) { 1094 assertEquals(connection.getAddress(), remoteConnection.getAddress()); 1095 assertEquals(connection.getAddressPresentation(), 1096 remoteConnection.getAddressPresentation()); 1097 assertEquals(connection.getCallerDisplayName(), remoteConnection.getCallerDisplayName()); 1098 assertEquals(connection.getCallerDisplayNamePresentation(), 1099 remoteConnection.getCallerDisplayNamePresentation()); 1100 assertEquals(connection.getConnectionCapabilities(), 1101 remoteConnection.getConnectionCapabilities()); 1102 assertEquals(connection.getDisconnectCause(), remoteConnection.getDisconnectCause()); 1103 assertEquals(connection.getExtras(), remoteConnection.getExtras()); 1104 assertEquals(connection.getStatusHints(), remoteConnection.getStatusHints()); 1105 assertEquals(VideoProfile.STATE_AUDIO_ONLY, remoteConnection.getVideoState()); 1106 assertNull(remoteConnection.getVideoProvider()); 1107 assertTrue(remoteConnection.getConferenceableConnections().isEmpty()); 1108 } 1109 1110 private void addRemoteConnectionOutgoingCall() { 1111 try { 1112 MockConnectionService managerConnectionService = new MockConnectionService() { 1113 @Override 1114 public Connection onCreateOutgoingConnection( 1115 PhoneAccountHandle connectionManagerPhoneAccount, 1116 ConnectionRequest request) { 1117 MockConnection connection = (MockConnection)super.onCreateOutgoingConnection( 1118 connectionManagerPhoneAccount, request); 1119 ConnectionRequest remoteRequest = new ConnectionRequest( 1120 TEST_REMOTE_PHONE_ACCOUNT_HANDLE, 1121 request.getAddress(), 1122 request.getExtras()); 1123 RemoteConnection remoteConnection = 1124 CtsConnectionService.createRemoteOutgoingConnectionToTelecom( 1125 TEST_REMOTE_PHONE_ACCOUNT_HANDLE, remoteRequest); 1126 connection.setRemoteConnection(remoteConnection); 1127 return connection; 1128 } 1129 }; 1130 setupConnectionServices(managerConnectionService, null, FLAG_REGISTER | FLAG_ENABLE); 1131 } catch(Exception e) { 1132 fail("Error in setting up the connection services"); 1133 } 1134 placeAndVerifyCall(); 1135 /** 1136 * Retrieve the connection from both the connection services and see if the plumbing via 1137 * RemoteConnection object is working. 1138 */ 1139 mConnection = verifyConnectionForOutgoingCall(); 1140 mRemoteConnection = verifyConnectionForOutgoingCallOnRemoteCS(); 1141 mRemoteConnectionObject = mConnection.getRemoteConnection(); 1142 } 1143 1144 private void addRemoteConnectionIncomingCall() { 1145 try { 1146 MockConnectionService managerConnectionService = new MockConnectionService() { 1147 @Override 1148 public Connection onCreateIncomingConnection( 1149 PhoneAccountHandle connectionManagerPhoneAccount, 1150 ConnectionRequest request) { 1151 MockConnection connection = (MockConnection)super.onCreateIncomingConnection( 1152 connectionManagerPhoneAccount, request); 1153 ConnectionRequest remoteRequest = new ConnectionRequest( 1154 TEST_REMOTE_PHONE_ACCOUNT_HANDLE, 1155 request.getAddress(), 1156 request.getExtras()); 1157 RemoteConnection remoteConnection = 1158 CtsConnectionService.createRemoteIncomingConnectionToTelecom( 1159 TEST_REMOTE_PHONE_ACCOUNT_HANDLE, remoteRequest); 1160 connection.setRemoteConnection(remoteConnection); 1161 return connection; 1162 } 1163 }; 1164 setupConnectionServices(managerConnectionService, null, FLAG_REGISTER | FLAG_ENABLE); 1165 } catch(Exception e) { 1166 fail("Error in setting up the connection services"); 1167 } 1168 addAndVerifyNewIncomingCall(createTestNumber(), null); 1169 /** 1170 * Retrieve the connection from both the connection services and see if the plumbing via 1171 * RemoteConnection object is working. 1172 */ 1173 mConnection = verifyConnectionForIncomingCall(); 1174 mRemoteConnection = verifyConnectionForIncomingCallOnRemoteCS(); 1175 mRemoteConnectionObject = mConnection.getRemoteConnection(); 1176 } 1177 1178 private Handler setupRemoteConnectionCallbacksTest() { 1179 addRemoteConnectionOutgoingCall(); 1180 final Call call = mInCallCallbacks.getService().getLastCall(); 1181 assertCallState(call, Call.STATE_DIALING); 1182 verifyRemoteConnectionObject(mRemoteConnectionObject, mRemoteConnection); 1183 1184 // Create a looper thread for the callbacks. 1185 HandlerThread workerThread = new HandlerThread("CallbackThread"); 1186 workerThread.start(); 1187 Handler handler = new Handler(workerThread.getLooper()); 1188 return handler; 1189 } 1190 1191 private Handler setupRemoteConnectionVideoCallbacksTest() { 1192 addRemoteConnectionOutgoingCall(); 1193 final Call call = mInCallCallbacks.getService().getLastCall(); 1194 assertCallState(call, Call.STATE_DIALING); 1195 verifyRemoteConnectionObject(mRemoteConnectionObject, mRemoteConnection); 1196 1197 // Create a looper thread for the callbacks. 1198 HandlerThread workerThread = new HandlerThread("CallbackThread"); 1199 workerThread.start(); 1200 Handler handler = new Handler(workerThread.getLooper()); 1201 1202 final InvokeCounter callbackInvoker = new InvokeCounter("RemoteConnectionCallbacks"); 1203 1204 RemoteConnection.Callback callback = new RemoteConnection.Callback() { 1205 @Override 1206 public void onVideoProviderChanged( 1207 RemoteConnection connection, VideoProvider videoProvider) { 1208 callbackInvoker.invoke(connection, videoProvider); 1209 } 1210 }; 1211 mRemoteConnectionObject.registerCallback(callback, handler); 1212 mRemoteConnection.createMockVideoProvider(); 1213 callbackInvoker.waitForCount(1, WAIT_FOR_STATE_CHANGE_TIMEOUT_MS); 1214 assertEquals(mRemoteConnectionObject, callbackInvoker.getArgs(0)[0]); 1215 mRemoteConnectionObject.unregisterCallback(callback); 1216 return handler; 1217 } 1218 1219 private Handler setupRemoteConnectionVideoTest(MockVideoProvider mockVideoProvider) { 1220 addRemoteConnectionOutgoingCall(); 1221 final Call call = mInCallCallbacks.getService().getLastCall(); 1222 assertCallState(call, Call.STATE_DIALING); 1223 verifyRemoteConnectionObject(mRemoteConnectionObject, mRemoteConnection); 1224 1225 // Create a looper thread for the callbacks. 1226 HandlerThread workerThread = new HandlerThread("CallbackThread"); 1227 workerThread.start(); 1228 Handler handler = new Handler(workerThread.getLooper()); 1229 1230 final InvokeCounter callbackInvoker = new InvokeCounter("RemoteConnectionCallbacks"); 1231 1232 RemoteConnection.Callback callback = new RemoteConnection.Callback() { 1233 @Override 1234 public void onVideoProviderChanged( 1235 RemoteConnection connection, VideoProvider videoProvider) { 1236 callbackInvoker.invoke(connection, videoProvider); 1237 } 1238 }; 1239 mRemoteConnectionObject.registerCallback(callback, handler); 1240 mRemoteConnection.setVideoProvider(mockVideoProvider); 1241 callbackInvoker.waitForCount(1, WAIT_FOR_STATE_CHANGE_TIMEOUT_MS); 1242 assertEquals(mRemoteConnectionObject, callbackInvoker.getArgs(0)[0]); 1243 mRemoteConnectionObject.unregisterCallback(callback); 1244 return handler; 1245 } 1246 } 1247