InCallService.java revision bf9c6fdb43413929787ee3abeb76e5aabd1551d8
1/* 2 * Copyright (C) 2013 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.annotation.SystemApi; 21import android.app.Service; 22import android.content.Intent; 23import android.hardware.camera2.CameraManager; 24import android.net.Uri; 25import android.os.Bundle; 26import android.os.Handler; 27import android.os.IBinder; 28import android.os.Looper; 29import android.os.Message; 30import android.view.Surface; 31 32import com.android.internal.os.SomeArgs; 33import com.android.internal.telecom.IInCallAdapter; 34import com.android.internal.telecom.IInCallService; 35 36import java.lang.String; 37import java.util.Collections; 38import java.util.List; 39 40/** 41 * This service is implemented by any app that wishes to provide the user-interface for managing 42 * phone calls. Telecom binds to this service while there exists a live (active or incoming) call, 43 * and uses it to notify the in-call app of any live and recently disconnected calls. An app must 44 * first be set as the default phone app (See {@link TelecomManager#getDefaultDialerPackage()}) 45 * before the telecom service will bind to its {@code InCallService} implementation. 46 * <p> 47 * Below is an example manifest registration for an {@code InCallService}. The meta-data 48 * ({@link TelecomManager#METADATA_IN_CALL_SERVICE_UI}) indicates that this particular 49 * {@code InCallService} implementation intends to replace the built-in in-call UI. 50 * <pre> 51 * {@code 52 * <service android:name="your.package.YourInCallServiceImplementation" 53 * android:permission="android.permission.BIND_INCALL_SERVICE"> 54 * <meta-data android:name="android.telecom.IN_CALL_SERVICE_UI" android:value="true" /> 55 * <intent-filter> 56 * <action android:name="android.telecom.InCallService"/> 57 * </intent-filter> 58 * </service> 59 * } 60 * </pre> 61 */ 62public abstract class InCallService extends Service { 63 64 /** 65 * The {@link Intent} that must be declared as handled by the service. 66 */ 67 @SdkConstant(SdkConstant.SdkConstantType.SERVICE_ACTION) 68 public static final String SERVICE_INTERFACE = "android.telecom.InCallService"; 69 70 private static final int MSG_SET_IN_CALL_ADAPTER = 1; 71 private static final int MSG_ADD_CALL = 2; 72 private static final int MSG_UPDATE_CALL = 3; 73 private static final int MSG_SET_POST_DIAL_WAIT = 4; 74 private static final int MSG_ON_CALL_AUDIO_STATE_CHANGED = 5; 75 private static final int MSG_BRING_TO_FOREGROUND = 6; 76 private static final int MSG_ON_CAN_ADD_CALL_CHANGED = 7; 77 private static final int MSG_SILENCE_RINGER = 8; 78 private static final int MSG_ON_CONNECTION_EVENT = 9; 79 80 /** Default Handler used to consolidate binder method calls onto a single thread. */ 81 private final Handler mHandler = new Handler(Looper.getMainLooper()) { 82 @Override 83 public void handleMessage(Message msg) { 84 if (mPhone == null && msg.what != MSG_SET_IN_CALL_ADAPTER) { 85 return; 86 } 87 88 switch (msg.what) { 89 case MSG_SET_IN_CALL_ADAPTER: 90 String callingPackage = getApplicationContext().getOpPackageName(); 91 mPhone = new Phone(new InCallAdapter((IInCallAdapter) msg.obj), callingPackage); 92 mPhone.addListener(mPhoneListener); 93 onPhoneCreated(mPhone); 94 break; 95 case MSG_ADD_CALL: 96 mPhone.internalAddCall((ParcelableCall) msg.obj); 97 break; 98 case MSG_UPDATE_CALL: 99 mPhone.internalUpdateCall((ParcelableCall) msg.obj); 100 break; 101 case MSG_SET_POST_DIAL_WAIT: { 102 SomeArgs args = (SomeArgs) msg.obj; 103 try { 104 String callId = (String) args.arg1; 105 String remaining = (String) args.arg2; 106 mPhone.internalSetPostDialWait(callId, remaining); 107 } finally { 108 args.recycle(); 109 } 110 break; 111 } 112 case MSG_ON_CALL_AUDIO_STATE_CHANGED: 113 mPhone.internalCallAudioStateChanged((CallAudioState) msg.obj); 114 break; 115 case MSG_BRING_TO_FOREGROUND: 116 mPhone.internalBringToForeground(msg.arg1 == 1); 117 break; 118 case MSG_ON_CAN_ADD_CALL_CHANGED: 119 mPhone.internalSetCanAddCall(msg.arg1 == 1); 120 break; 121 case MSG_SILENCE_RINGER: 122 mPhone.internalSilenceRinger(); 123 break; 124 case MSG_ON_CONNECTION_EVENT: { 125 SomeArgs args = (SomeArgs) msg.obj; 126 try { 127 String callId = (String) args.arg1; 128 String event = (String) args.arg2; 129 Bundle extras = (Bundle) args.arg3; 130 mPhone.internalOnConnectionEvent(callId, event, extras); 131 } finally { 132 args.recycle(); 133 } 134 break; 135 } 136 default: 137 break; 138 } 139 } 140 }; 141 142 /** Manages the binder calls so that the implementor does not need to deal with it. */ 143 private final class InCallServiceBinder extends IInCallService.Stub { 144 @Override 145 public void setInCallAdapter(IInCallAdapter inCallAdapter) { 146 mHandler.obtainMessage(MSG_SET_IN_CALL_ADAPTER, inCallAdapter).sendToTarget(); 147 } 148 149 @Override 150 public void addCall(ParcelableCall call) { 151 mHandler.obtainMessage(MSG_ADD_CALL, call).sendToTarget(); 152 } 153 154 @Override 155 public void updateCall(ParcelableCall call) { 156 mHandler.obtainMessage(MSG_UPDATE_CALL, call).sendToTarget(); 157 } 158 159 @Override 160 public void setPostDial(String callId, String remaining) { 161 // TODO: Unused 162 } 163 164 @Override 165 public void setPostDialWait(String callId, String remaining) { 166 SomeArgs args = SomeArgs.obtain(); 167 args.arg1 = callId; 168 args.arg2 = remaining; 169 mHandler.obtainMessage(MSG_SET_POST_DIAL_WAIT, args).sendToTarget(); 170 } 171 172 @Override 173 public void onCallAudioStateChanged(CallAudioState callAudioState) { 174 mHandler.obtainMessage(MSG_ON_CALL_AUDIO_STATE_CHANGED, callAudioState).sendToTarget(); 175 } 176 177 @Override 178 public void bringToForeground(boolean showDialpad) { 179 mHandler.obtainMessage(MSG_BRING_TO_FOREGROUND, showDialpad ? 1 : 0, 0).sendToTarget(); 180 } 181 182 @Override 183 public void onCanAddCallChanged(boolean canAddCall) { 184 mHandler.obtainMessage(MSG_ON_CAN_ADD_CALL_CHANGED, canAddCall ? 1 : 0, 0) 185 .sendToTarget(); 186 } 187 188 @Override 189 public void silenceRinger() { 190 mHandler.obtainMessage(MSG_SILENCE_RINGER).sendToTarget(); 191 } 192 193 @Override 194 public void onConnectionEvent(String callId, String event, Bundle extras) { 195 SomeArgs args = SomeArgs.obtain(); 196 args.arg1 = callId; 197 args.arg2 = event; 198 args.arg3 = extras; 199 mHandler.obtainMessage(MSG_ON_CONNECTION_EVENT, args).sendToTarget(); 200 } 201 } 202 203 private Phone.Listener mPhoneListener = new Phone.Listener() { 204 /** ${inheritDoc} */ 205 @Override 206 public void onAudioStateChanged(Phone phone, AudioState audioState) { 207 InCallService.this.onAudioStateChanged(audioState); 208 } 209 210 public void onCallAudioStateChanged(Phone phone, CallAudioState callAudioState) { 211 InCallService.this.onCallAudioStateChanged(callAudioState); 212 }; 213 214 /** ${inheritDoc} */ 215 @Override 216 public void onBringToForeground(Phone phone, boolean showDialpad) { 217 InCallService.this.onBringToForeground(showDialpad); 218 } 219 220 /** ${inheritDoc} */ 221 @Override 222 public void onCallAdded(Phone phone, Call call) { 223 InCallService.this.onCallAdded(call); 224 } 225 226 /** ${inheritDoc} */ 227 @Override 228 public void onCallRemoved(Phone phone, Call call) { 229 InCallService.this.onCallRemoved(call); 230 } 231 232 /** ${inheritDoc} */ 233 @Override 234 public void onCanAddCallChanged(Phone phone, boolean canAddCall) { 235 InCallService.this.onCanAddCallChanged(canAddCall); 236 } 237 238 /** ${inheritDoc} */ 239 @Override 240 public void onSilenceRinger(Phone phone) { 241 InCallService.this.onSilenceRinger(); 242 } 243 244 }; 245 246 private Phone mPhone; 247 248 public InCallService() { 249 } 250 251 @Override 252 public IBinder onBind(Intent intent) { 253 return new InCallServiceBinder(); 254 } 255 256 @Override 257 public boolean onUnbind(Intent intent) { 258 if (mPhone != null) { 259 Phone oldPhone = mPhone; 260 mPhone = null; 261 262 oldPhone.destroy(); 263 // destroy sets all the calls to disconnected if any live ones still exist. Therefore, 264 // it is important to remove the Listener *after* the call to destroy so that 265 // InCallService.on* callbacks are appropriately called. 266 oldPhone.removeListener(mPhoneListener); 267 268 onPhoneDestroyed(oldPhone); 269 } 270 271 return false; 272 } 273 274 /** 275 * Obtain the {@code Phone} associated with this {@code InCallService}. 276 * 277 * @return The {@code Phone} object associated with this {@code InCallService}, or {@code null} 278 * if the {@code InCallService} is not in a state where it has an associated 279 * {@code Phone}. 280 * @hide 281 * @deprecated Use direct methods on InCallService instead of {@link Phone}. 282 */ 283 @SystemApi 284 @Deprecated 285 public Phone getPhone() { 286 return mPhone; 287 } 288 289 /** 290 * Obtains the current list of {@code Call}s to be displayed by this in-call service. 291 * 292 * @return A list of the relevant {@code Call}s. 293 */ 294 public final List<Call> getCalls() { 295 return mPhone == null ? Collections.<Call>emptyList() : mPhone.getCalls(); 296 } 297 298 /** 299 * Returns if the device can support additional calls. 300 * 301 * @return Whether the phone supports adding more calls. 302 */ 303 public final boolean canAddCall() { 304 return mPhone == null ? false : mPhone.canAddCall(); 305 } 306 307 /** 308 * Obtains the current phone call audio state. 309 * 310 * @return An object encapsulating the audio state. Returns null if the service is not 311 * fully initialized. 312 * @deprecated Use {@link #getCallAudioState()} instead. 313 * @hide 314 */ 315 @Deprecated 316 public final AudioState getAudioState() { 317 return mPhone == null ? null : mPhone.getAudioState(); 318 } 319 320 /** 321 * Obtains the current phone call audio state. 322 * 323 * @return An object encapsulating the audio state. Returns null if the service is not 324 * fully initialized. 325 */ 326 public final CallAudioState getCallAudioState() { 327 return mPhone == null ? null : mPhone.getCallAudioState(); 328 } 329 330 /** 331 * Sets the microphone mute state. When this request is honored, there will be change to 332 * the {@link #getCallAudioState()}. 333 * 334 * @param state {@code true} if the microphone should be muted; {@code false} otherwise. 335 */ 336 public final void setMuted(boolean state) { 337 if (mPhone != null) { 338 mPhone.setMuted(state); 339 } 340 } 341 342 /** 343 * Sets the audio route (speaker, bluetooth, etc...). When this request is honored, there will 344 * be change to the {@link #getCallAudioState()}. 345 * 346 * @param route The audio route to use. 347 */ 348 public final void setAudioRoute(int route) { 349 if (mPhone != null) { 350 mPhone.setAudioRoute(route); 351 } 352 } 353 354 /** 355 * Invoked when the {@code Phone} has been created. This is a signal to the in-call experience 356 * to start displaying in-call information to the user. Each instance of {@code InCallService} 357 * will have only one {@code Phone}, and this method will be called exactly once in the lifetime 358 * of the {@code InCallService}. 359 * 360 * @param phone The {@code Phone} object associated with this {@code InCallService}. 361 * @hide 362 * @deprecated Use direct methods on InCallService instead of {@link Phone}. 363 */ 364 @SystemApi 365 @Deprecated 366 public void onPhoneCreated(Phone phone) { 367 } 368 369 /** 370 * Invoked when a {@code Phone} has been destroyed. This is a signal to the in-call experience 371 * to stop displaying in-call information to the user. This method will be called exactly once 372 * in the lifetime of the {@code InCallService}, and it will always be called after a previous 373 * call to {@link #onPhoneCreated(Phone)}. 374 * 375 * @param phone The {@code Phone} object associated with this {@code InCallService}. 376 * @hide 377 * @deprecated Use direct methods on InCallService instead of {@link Phone}. 378 */ 379 @SystemApi 380 @Deprecated 381 public void onPhoneDestroyed(Phone phone) { 382 } 383 384 /** 385 * Called when the audio state changes. 386 * 387 * @param audioState The new {@link AudioState}. 388 * @deprecated Use {@link #onCallAudioStateChanged(CallAudioState) instead}. 389 * @hide 390 */ 391 @Deprecated 392 public void onAudioStateChanged(AudioState audioState) { 393 } 394 395 /** 396 * Called when the audio state changes. 397 * 398 * @param audioState The new {@link CallAudioState}. 399 */ 400 public void onCallAudioStateChanged(CallAudioState audioState) { 401 } 402 403 /** 404 * Called to bring the in-call screen to the foreground. The in-call experience should 405 * respond immediately by coming to the foreground to inform the user of the state of 406 * ongoing {@code Call}s. 407 * 408 * @param showDialpad If true, put up the dialpad when the screen is shown. 409 */ 410 public void onBringToForeground(boolean showDialpad) { 411 } 412 413 /** 414 * Called when a {@code Call} has been added to this in-call session. The in-call user 415 * experience should add necessary state listeners to the specified {@code Call} and 416 * immediately start to show the user information about the existence 417 * and nature of this {@code Call}. Subsequent invocations of {@link #getCalls()} will 418 * include this {@code Call}. 419 * 420 * @param call A newly added {@code Call}. 421 */ 422 public void onCallAdded(Call call) { 423 } 424 425 /** 426 * Called when a {@code Call} has been removed from this in-call session. The in-call user 427 * experience should remove any state listeners from the specified {@code Call} and 428 * immediately stop displaying any information about this {@code Call}. 429 * Subsequent invocations of {@link #getCalls()} will no longer include this {@code Call}. 430 * 431 * @param call A newly removed {@code Call}. 432 */ 433 public void onCallRemoved(Call call) { 434 } 435 436 /** 437 * Called when the ability to add more calls changes. If the phone cannot 438 * support more calls then {@code canAddCall} is set to {@code false}. If it can, then it 439 * is set to {@code true}. This can be used to control the visibility of UI to add more calls. 440 * 441 * @param canAddCall Indicates whether an additional call can be added. 442 */ 443 public void onCanAddCallChanged(boolean canAddCall) { 444 } 445 446 /** 447 * Called to silence the ringer if a ringing call exists. 448 */ 449 public void onSilenceRinger() { 450 } 451 452 /** 453 * Unused; to handle connection events issued by a {@link ConnectionService}, implement the 454 * {@link android.telecom.Call.Callback#onConnectionEvent(Call, String, Bundle)} callback. 455 * <p> 456 * See {@link Connection#sendConnectionEvent(String, Bundle)}. 457 * 458 * @param call The call the event is associated with. 459 * @param event The event. 460 * @param extras Any associated extras. 461 */ 462 public void onConnectionEvent(Call call, String event, Bundle extras) { 463 } 464 465 /** 466 * Used to issue commands to the {@link Connection.VideoProvider} associated with a 467 * {@link Call}. 468 */ 469 public static abstract class VideoCall { 470 471 /** @hide */ 472 public abstract void destroy(); 473 474 /** 475 * Registers a callback to receive commands and state changes for video calls. 476 * 477 * @param callback The video call callback. 478 */ 479 public abstract void registerCallback(VideoCall.Callback callback); 480 481 /** 482 * Registers a callback to receive commands and state changes for video calls. 483 * 484 * @param callback The video call callback. 485 * @param handler A handler which commands and status changes will be delivered to. 486 */ 487 public abstract void registerCallback(VideoCall.Callback callback, Handler handler); 488 489 /** 490 * Clears the video call callback set via {@link #registerCallback}. 491 * 492 * @param callback The video call callback to clear. 493 */ 494 public abstract void unregisterCallback(VideoCall.Callback callback); 495 496 /** 497 * Sets the camera to be used for the outgoing video. 498 * <p> 499 * Handled by {@link Connection.VideoProvider#onSetCamera(String)}. 500 * 501 * @param cameraId The id of the camera (use ids as reported by 502 * {@link CameraManager#getCameraIdList()}). 503 */ 504 public abstract void setCamera(String cameraId); 505 506 /** 507 * Sets the surface to be used for displaying a preview of what the user's camera is 508 * currently capturing. When video transmission is enabled, this is the video signal which 509 * is sent to the remote device. 510 * <p> 511 * Handled by {@link Connection.VideoProvider#onSetPreviewSurface(Surface)}. 512 * 513 * @param surface The {@link Surface}. 514 */ 515 public abstract void setPreviewSurface(Surface surface); 516 517 /** 518 * Sets the surface to be used for displaying the video received from the remote device. 519 * <p> 520 * Handled by {@link Connection.VideoProvider#onSetDisplaySurface(Surface)}. 521 * 522 * @param surface The {@link Surface}. 523 */ 524 public abstract void setDisplaySurface(Surface surface); 525 526 /** 527 * Sets the device orientation, in degrees. Assumes that a standard portrait orientation of 528 * the device is 0 degrees. 529 * <p> 530 * Handled by {@link Connection.VideoProvider#onSetDeviceOrientation(int)}. 531 * 532 * @param rotation The device orientation, in degrees. 533 */ 534 public abstract void setDeviceOrientation(int rotation); 535 536 /** 537 * Sets camera zoom ratio. 538 * <p> 539 * Handled by {@link Connection.VideoProvider#onSetZoom(float)}. 540 * 541 * @param value The camera zoom ratio. 542 */ 543 public abstract void setZoom(float value); 544 545 /** 546 * Issues a request to modify the properties of the current video session. 547 * <p> 548 * Example scenarios include: requesting an audio-only call to be upgraded to a 549 * bi-directional video call, turning on or off the user's camera, sending a pause signal 550 * when the {@link InCallService} is no longer the foreground application. 551 * <p> 552 * Handled by 553 * {@link Connection.VideoProvider#onSendSessionModifyRequest(VideoProfile, VideoProfile)}. 554 * 555 * @param requestProfile The requested call video properties. 556 */ 557 public abstract void sendSessionModifyRequest(VideoProfile requestProfile); 558 559 /** 560 * Provides a response to a request to change the current call video session 561 * properties. This should be called in response to a request the {@link InCallService} has 562 * received via {@link VideoCall.Callback#onSessionModifyRequestReceived}. 563 * <p> 564 * Handled by 565 * {@link Connection.VideoProvider#onSendSessionModifyResponse(VideoProfile)}. 566 * 567 * @param responseProfile The response call video properties. 568 */ 569 public abstract void sendSessionModifyResponse(VideoProfile responseProfile); 570 571 /** 572 * Issues a request to the {@link Connection.VideoProvider} to retrieve the capabilities 573 * of the current camera. The current camera is selected using 574 * {@link VideoCall#setCamera(String)}. 575 * <p> 576 * Camera capabilities are reported to the caller via 577 * {@link VideoCall.Callback#onCameraCapabilitiesChanged(VideoProfile.CameraCapabilities)}. 578 * <p> 579 * Handled by {@link Connection.VideoProvider#onRequestCameraCapabilities()}. 580 */ 581 public abstract void requestCameraCapabilities(); 582 583 /** 584 * Issues a request to the {@link Connection.VideoProvider} to retrieve the cumulative data 585 * usage for the video component of the current call (in bytes). Data usage is reported 586 * to the caller via {@link VideoCall.Callback#onCallDataUsageChanged}. 587 * <p> 588 * Handled by {@link Connection.VideoProvider#onRequestConnectionDataUsage()}. 589 */ 590 public abstract void requestCallDataUsage(); 591 592 /** 593 * Provides the {@link Connection.VideoProvider} with the {@link Uri} of an image to be 594 * displayed to the peer device when the video signal is paused. 595 * <p> 596 * Handled by {@link Connection.VideoProvider#onSetPauseImage(Uri)}. 597 * 598 * @param uri URI of image to display. 599 */ 600 public abstract void setPauseImage(Uri uri); 601 602 /** 603 * The {@link InCallService} extends this class to provide a means of receiving callbacks 604 * from the {@link Connection.VideoProvider}. 605 * <p> 606 * When the {@link InCallService} receives the 607 * {@link Call.Callback#onVideoCallChanged(Call, VideoCall)} callback, it should create an 608 * instance its {@link VideoCall.Callback} implementation and set it on the 609 * {@link VideoCall} using {@link VideoCall#registerCallback(Callback)}. 610 */ 611 public static abstract class Callback { 612 /** 613 * Called when the {@link Connection.VideoProvider} receives a session modification 614 * request from the peer device. 615 * <p> 616 * The {@link InCallService} may potentially prompt the user to confirm whether they 617 * wish to accept the request, or decide to automatically accept the request. In either 618 * case the {@link InCallService} should call 619 * {@link VideoCall#sendSessionModifyResponse(VideoProfile)} to indicate the video 620 * profile agreed upon. 621 * <p> 622 * Callback originates from 623 * {@link Connection.VideoProvider#receiveSessionModifyRequest(VideoProfile)}. 624 * 625 * @param videoProfile The requested video profile. 626 */ 627 public abstract void onSessionModifyRequestReceived(VideoProfile videoProfile); 628 629 /** 630 * Called when the {@link Connection.VideoProvider} receives a response to a session 631 * modification request previously sent to the peer device. 632 * <p> 633 * The new video state should not be considered active by the {@link InCallService} 634 * until the {@link Call} video state changes (the 635 * {@link Call.Callback#onDetailsChanged(Call, Call.Details)} callback is triggered 636 * when the video state changes). 637 * <p> 638 * Callback originates from 639 * {@link Connection.VideoProvider#receiveSessionModifyResponse(int, VideoProfile, 640 * VideoProfile)}. 641 * 642 * @param status Status of the session modify request. Valid values are 643 * {@link Connection.VideoProvider#SESSION_MODIFY_REQUEST_SUCCESS}, 644 * {@link Connection.VideoProvider#SESSION_MODIFY_REQUEST_FAIL}, 645 * {@link Connection.VideoProvider#SESSION_MODIFY_REQUEST_INVALID}, 646 * {@link Connection.VideoProvider#SESSION_MODIFY_REQUEST_TIMED_OUT}, 647 * {@link Connection.VideoProvider#SESSION_MODIFY_REQUEST_REJECTED_BY_REMOTE}. 648 * @param requestedProfile The original request which was sent to the peer device. 649 * @param responseProfile The actual profile changes made by the peer device. 650 */ 651 public abstract void onSessionModifyResponseReceived(int status, 652 VideoProfile requestedProfile, VideoProfile responseProfile); 653 654 /** 655 * Handles events related to the current video session which the {@link InCallService} 656 * may wish to handle. These are separate from requested changes to the session due to 657 * the underlying protocol or connection. 658 * <p> 659 * Callback originates from 660 * {@link Connection.VideoProvider#handleCallSessionEvent(int)}. 661 * 662 * @param event The event. Valid values are: 663 * {@link Connection.VideoProvider#SESSION_EVENT_RX_PAUSE}, 664 * {@link Connection.VideoProvider#SESSION_EVENT_RX_RESUME}, 665 * {@link Connection.VideoProvider#SESSION_EVENT_TX_START}, 666 * {@link Connection.VideoProvider#SESSION_EVENT_TX_STOP}, 667 * {@link Connection.VideoProvider#SESSION_EVENT_CAMERA_FAILURE}, 668 * {@link Connection.VideoProvider#SESSION_EVENT_CAMERA_READY}, 669 * {@link Connection.VideoProvider#SESSION_EVENT_CAMERA_PERMISSION_ERROR}. 670 */ 671 public abstract void onCallSessionEvent(int event); 672 673 /** 674 * Handles a change to the video dimensions from the peer device. This could happen if, 675 * for example, the peer changes orientation of their device, or switches cameras. 676 * <p> 677 * Callback originates from 678 * {@link Connection.VideoProvider#changePeerDimensions(int, int)}. 679 * 680 * @param width The updated peer video width. 681 * @param height The updated peer video height. 682 */ 683 public abstract void onPeerDimensionsChanged(int width, int height); 684 685 /** 686 * Handles a change to the video quality. 687 * <p> 688 * Callback originates from {@link Connection.VideoProvider#changeVideoQuality(int)}. 689 * 690 * @param videoQuality The updated peer video quality. Valid values: 691 * {@link VideoProfile#QUALITY_HIGH}, 692 * {@link VideoProfile#QUALITY_MEDIUM}, 693 * {@link VideoProfile#QUALITY_LOW}, 694 * {@link VideoProfile#QUALITY_DEFAULT}. 695 */ 696 public abstract void onVideoQualityChanged(int videoQuality); 697 698 /** 699 * Handles an update to the total data used for the current video session. 700 * <p> 701 * Used by the {@link Connection.VideoProvider} in response to 702 * {@link VideoCall#requestCallDataUsage()}. May also be called periodically by the 703 * {@link Connection.VideoProvider}. 704 * <p> 705 * Callback originates from {@link Connection.VideoProvider#setCallDataUsage(long)}. 706 * 707 * @param dataUsage The updated data usage (in bytes). 708 */ 709 public abstract void onCallDataUsageChanged(long dataUsage); 710 711 /** 712 * Handles a change in the capabilities of the currently selected camera. 713 * <p> 714 * Used by the {@link Connection.VideoProvider} in response to 715 * {@link VideoCall#requestCameraCapabilities()}. The {@link Connection.VideoProvider} 716 * may also report the camera capabilities after a call to 717 * {@link VideoCall#setCamera(String)}. 718 * <p> 719 * Callback originates from 720 * {@link Connection.VideoProvider#changeCameraCapabilities( 721 * VideoProfile.CameraCapabilities)}. 722 * 723 * @param cameraCapabilities The changed camera capabilities. 724 */ 725 public abstract void onCameraCapabilitiesChanged( 726 VideoProfile.CameraCapabilities cameraCapabilities); 727 } 728 } 729} 730