4538216a31
Including a fromProfile in addition to the requestedProfile. - Changed VideoCallImpl to generate the fromVideoProfile based on the call's current videoState. This ensures the InCall UI only needs to pass in the new video profile; the VideoCall Impl already has enough knowledge to generate the fromProfile. - Changed VideoCallImpl to track the current videoQuality, which forms a part of the fromVideoProfile. Bug: 20704229 Change-Id: I89f293f03a2b13fc8c1dcfd8a07ab8640d3950e0
1207 lines
44 KiB
Java
1207 lines
44 KiB
Java
/*
|
|
* Copyright (C) 2014 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
package android.telecom;
|
|
|
|
import android.annotation.SystemApi;
|
|
import android.net.Uri;
|
|
import android.os.Bundle;
|
|
import android.os.Handler;
|
|
|
|
import java.lang.String;
|
|
import java.util.ArrayList;
|
|
import java.util.Collections;
|
|
import java.util.LinkedList;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.Objects;
|
|
import java.util.concurrent.CopyOnWriteArrayList;
|
|
|
|
/**
|
|
* Represents an ongoing phone call that the in-call app should present to the user.
|
|
*/
|
|
public final class Call {
|
|
/**
|
|
* The state of a {@code Call} when newly created.
|
|
*/
|
|
public static final int STATE_NEW = 0;
|
|
|
|
/**
|
|
* The state of an outgoing {@code Call} when dialing the remote number, but not yet connected.
|
|
*/
|
|
public static final int STATE_DIALING = 1;
|
|
|
|
/**
|
|
* The state of an incoming {@code Call} when ringing locally, but not yet connected.
|
|
*/
|
|
public static final int STATE_RINGING = 2;
|
|
|
|
/**
|
|
* The state of a {@code Call} when in a holding state.
|
|
*/
|
|
public static final int STATE_HOLDING = 3;
|
|
|
|
/**
|
|
* The state of a {@code Call} when actively supporting conversation.
|
|
*/
|
|
public static final int STATE_ACTIVE = 4;
|
|
|
|
/**
|
|
* The state of a {@code Call} when no further voice or other communication is being
|
|
* transmitted, the remote side has been or will inevitably be informed that the {@code Call}
|
|
* is no longer active, and the local data transport has or inevitably will release resources
|
|
* associated with this {@code Call}.
|
|
*/
|
|
public static final int STATE_DISCONNECTED = 7;
|
|
|
|
/**
|
|
* The state of an outgoing {@code Call} when waiting on user to select a
|
|
* {@link PhoneAccount} through which to place the call.
|
|
*/
|
|
public static final int STATE_SELECT_PHONE_ACCOUNT = 8;
|
|
|
|
/**
|
|
* @hide
|
|
* @deprecated use STATE_SELECT_PHONE_ACCOUNT.
|
|
*/
|
|
@Deprecated
|
|
@SystemApi
|
|
public static final int STATE_PRE_DIAL_WAIT = STATE_SELECT_PHONE_ACCOUNT;
|
|
|
|
/**
|
|
* The initial state of an outgoing {@code Call}.
|
|
* Common transitions are to {@link #STATE_DIALING} state for a successful call or
|
|
* {@link #STATE_DISCONNECTED} if it failed.
|
|
*/
|
|
public static final int STATE_CONNECTING = 9;
|
|
|
|
/**
|
|
* The state of a {@code Call} when the user has initiated a disconnection of the call, but the
|
|
* call has not yet been disconnected by the underlying {@code ConnectionService}. The next
|
|
* state of the call is (potentially) {@link #STATE_DISCONNECTED}.
|
|
*/
|
|
public static final int STATE_DISCONNECTING = 10;
|
|
|
|
/**
|
|
* The key to retrieve the optional {@code PhoneAccount}s Telecom can bundle with its Call
|
|
* extras. Used to pass the phone accounts to display on the front end to the user in order to
|
|
* select phone accounts to (for example) place a call.
|
|
*/
|
|
public static final String AVAILABLE_PHONE_ACCOUNTS = "selectPhoneAccountAccounts";
|
|
|
|
public static class Details {
|
|
|
|
/** Call can currently be put on hold or unheld. */
|
|
public static final int CAPABILITY_HOLD = 0x00000001;
|
|
|
|
/** Call supports the hold feature. */
|
|
public static final int CAPABILITY_SUPPORT_HOLD = 0x00000002;
|
|
|
|
/**
|
|
* Calls within a conference can be merged. A {@link ConnectionService} has the option to
|
|
* add a {@link Conference} call before the child {@link Connection}s are merged. This is how
|
|
* CDMA-based {@link Connection}s are implemented. For these unmerged {@link Conference}s, this
|
|
* capability allows a merge button to be shown while the conference call is in the foreground
|
|
* of the in-call UI.
|
|
* <p>
|
|
* This is only intended for use by a {@link Conference}.
|
|
*/
|
|
public static final int CAPABILITY_MERGE_CONFERENCE = 0x00000004;
|
|
|
|
/**
|
|
* Calls within a conference can be swapped between foreground and background.
|
|
* See {@link #CAPABILITY_MERGE_CONFERENCE} for additional information.
|
|
* <p>
|
|
* This is only intended for use by a {@link Conference}.
|
|
*/
|
|
public static final int CAPABILITY_SWAP_CONFERENCE = 0x00000008;
|
|
|
|
/**
|
|
* @hide
|
|
*/
|
|
public static final int CAPABILITY_UNUSED_1 = 0x00000010;
|
|
|
|
/** Call supports responding via text option. */
|
|
public static final int CAPABILITY_RESPOND_VIA_TEXT = 0x00000020;
|
|
|
|
/** Call can be muted. */
|
|
public static final int CAPABILITY_MUTE = 0x00000040;
|
|
|
|
/**
|
|
* Call supports conference call management. This capability only applies to {@link Conference}
|
|
* calls which can have {@link Connection}s as children.
|
|
*/
|
|
public static final int CAPABILITY_MANAGE_CONFERENCE = 0x00000080;
|
|
|
|
/**
|
|
* Local device supports receiving video.
|
|
*/
|
|
public static final int CAPABILITY_SUPPORTS_VT_LOCAL_RX = 0x00000100;
|
|
|
|
/**
|
|
* Local device supports transmitting video.
|
|
*/
|
|
public static final int CAPABILITY_SUPPORTS_VT_LOCAL_TX = 0x00000200;
|
|
|
|
/**
|
|
* Local device supports bidirectional video calling.
|
|
*/
|
|
public static final int CAPABILITY_SUPPORTS_VT_LOCAL_BIDIRECTIONAL =
|
|
CAPABILITY_SUPPORTS_VT_LOCAL_RX | CAPABILITY_SUPPORTS_VT_LOCAL_TX;
|
|
|
|
/**
|
|
* Remote device supports receiving video.
|
|
*/
|
|
public static final int CAPABILITY_SUPPORTS_VT_REMOTE_RX = 0x00000400;
|
|
|
|
/**
|
|
* Remote device supports transmitting video.
|
|
*/
|
|
public static final int CAPABILITY_SUPPORTS_VT_REMOTE_TX = 0x00000800;
|
|
|
|
/**
|
|
* Remote device supports bidirectional video calling.
|
|
*/
|
|
public static final int CAPABILITY_SUPPORTS_VT_REMOTE_BIDIRECTIONAL =
|
|
CAPABILITY_SUPPORTS_VT_REMOTE_RX | CAPABILITY_SUPPORTS_VT_REMOTE_TX;
|
|
|
|
/**
|
|
* Call is able to be separated from its parent {@code Conference}, if any.
|
|
*/
|
|
public static final int CAPABILITY_SEPARATE_FROM_CONFERENCE = 0x00001000;
|
|
|
|
/**
|
|
* Call is able to be individually disconnected when in a {@code Conference}.
|
|
*/
|
|
public static final int CAPABILITY_DISCONNECT_FROM_CONFERENCE = 0x00002000;
|
|
|
|
/**
|
|
* Speed up audio setup for MT call.
|
|
* @hide
|
|
*/
|
|
public static final int CAPABILITY_SPEED_UP_MT_AUDIO = 0x00040000;
|
|
|
|
/**
|
|
* Call can be upgraded to a video call.
|
|
* @hide
|
|
*/
|
|
public static final int CAPABILITY_CAN_UPGRADE_TO_VIDEO = 0x00080000;
|
|
|
|
/**
|
|
* For video calls, indicates whether the outgoing video for the call can be paused using
|
|
* the {@link android.telecom.VideoProfile.VideoState#PAUSED} VideoState.
|
|
*/
|
|
public static final int CAPABILITY_CAN_PAUSE_VIDEO = 0x00100000;
|
|
|
|
//******************************************************************************************
|
|
// Next CAPABILITY value: 0x00004000
|
|
//******************************************************************************************
|
|
|
|
/**
|
|
* Whether the call is currently a conference.
|
|
*/
|
|
public static final int PROPERTY_CONFERENCE = 0x00000001;
|
|
|
|
/**
|
|
* Whether the call is a generic conference, where we do not know the precise state of
|
|
* participants in the conference (eg. on CDMA).
|
|
*/
|
|
public static final int PROPERTY_GENERIC_CONFERENCE = 0x00000002;
|
|
|
|
/**
|
|
* Whether the call is made while the device is in emergency callback mode.
|
|
*/
|
|
public static final int PROPERTY_EMERGENCY_CALLBACK_MODE = 0x00000004;
|
|
|
|
/**
|
|
* Connection is using WIFI.
|
|
*/
|
|
public static final int PROPERTY_WIFI = 0x00000008;
|
|
|
|
/**
|
|
* Call is using high definition audio.
|
|
*/
|
|
public static final int PROPERTY_HIGH_DEF_AUDIO = 0x00000010;
|
|
|
|
//******************************************************************************************
|
|
// Next PROPERTY value: 0x00000020
|
|
//******************************************************************************************
|
|
|
|
private final Uri mHandle;
|
|
private final int mHandlePresentation;
|
|
private final String mCallerDisplayName;
|
|
private final int mCallerDisplayNamePresentation;
|
|
private final PhoneAccountHandle mAccountHandle;
|
|
private final int mCallCapabilities;
|
|
private final int mCallProperties;
|
|
private final DisconnectCause mDisconnectCause;
|
|
private final long mConnectTimeMillis;
|
|
private final GatewayInfo mGatewayInfo;
|
|
private final int mVideoState;
|
|
private final StatusHints mStatusHints;
|
|
private final Bundle mExtras;
|
|
|
|
/**
|
|
* Whether the supplied capabilities supports the specified capability.
|
|
*
|
|
* @param capabilities A bit field of capabilities.
|
|
* @param capability The capability to check capabilities for.
|
|
* @return Whether the specified capability is supported.
|
|
*/
|
|
public static boolean can(int capabilities, int capability) {
|
|
return (capabilities & capability) != 0;
|
|
}
|
|
|
|
/**
|
|
* Whether the capabilities of this {@code Details} supports the specified capability.
|
|
*
|
|
* @param capability The capability to check capabilities for.
|
|
* @return Whether the specified capability is supported.
|
|
*/
|
|
public boolean can(int capability) {
|
|
return can(mCallCapabilities, capability);
|
|
}
|
|
|
|
/**
|
|
* Render a set of capability bits ({@code CAPABILITY_*}) as a human readable string.
|
|
*
|
|
* @param capabilities A capability bit field.
|
|
* @return A human readable string representation.
|
|
*/
|
|
public static String capabilitiesToString(int capabilities) {
|
|
StringBuilder builder = new StringBuilder();
|
|
builder.append("[Capabilities:");
|
|
if (can(capabilities, CAPABILITY_HOLD)) {
|
|
builder.append(" CAPABILITY_HOLD");
|
|
}
|
|
if (can(capabilities, CAPABILITY_SUPPORT_HOLD)) {
|
|
builder.append(" CAPABILITY_SUPPORT_HOLD");
|
|
}
|
|
if (can(capabilities, CAPABILITY_MERGE_CONFERENCE)) {
|
|
builder.append(" CAPABILITY_MERGE_CONFERENCE");
|
|
}
|
|
if (can(capabilities, CAPABILITY_SWAP_CONFERENCE)) {
|
|
builder.append(" CAPABILITY_SWAP_CONFERENCE");
|
|
}
|
|
if (can(capabilities, CAPABILITY_RESPOND_VIA_TEXT)) {
|
|
builder.append(" CAPABILITY_RESPOND_VIA_TEXT");
|
|
}
|
|
if (can(capabilities, CAPABILITY_MUTE)) {
|
|
builder.append(" CAPABILITY_MUTE");
|
|
}
|
|
if (can(capabilities, CAPABILITY_MANAGE_CONFERENCE)) {
|
|
builder.append(" CAPABILITY_MANAGE_CONFERENCE");
|
|
}
|
|
if (can(capabilities, CAPABILITY_SUPPORTS_VT_LOCAL_RX)) {
|
|
builder.append(" CAPABILITY_SUPPORTS_VT_LOCAL_RX");
|
|
}
|
|
if (can(capabilities, CAPABILITY_SUPPORTS_VT_LOCAL_TX)) {
|
|
builder.append(" CAPABILITY_SUPPORTS_VT_LOCAL_TX");
|
|
}
|
|
if (can(capabilities, CAPABILITY_SUPPORTS_VT_LOCAL_BIDIRECTIONAL)) {
|
|
builder.append(" CAPABILITY_SUPPORTS_VT_LOCAL_BIDIRECTIONAL");
|
|
}
|
|
if (can(capabilities, CAPABILITY_SUPPORTS_VT_REMOTE_RX)) {
|
|
builder.append(" CAPABILITY_SUPPORTS_VT_REMOTE_RX");
|
|
}
|
|
if (can(capabilities, CAPABILITY_SUPPORTS_VT_REMOTE_TX)) {
|
|
builder.append(" CAPABILITY_SUPPORTS_VT_REMOTE_TX");
|
|
}
|
|
if (can(capabilities, CAPABILITY_SUPPORTS_VT_REMOTE_BIDIRECTIONAL)) {
|
|
builder.append(" CAPABILITY_SUPPORTS_VT_REMOTE_BIDIRECTIONAL");
|
|
}
|
|
if (can(capabilities, CAPABILITY_SPEED_UP_MT_AUDIO)) {
|
|
builder.append(" CAPABILITY_SPEED_UP_MT_AUDIO");
|
|
}
|
|
if (can(capabilities, CAPABILITY_CAN_UPGRADE_TO_VIDEO)) {
|
|
builder.append(" CAPABILITY_CAN_UPGRADE_TO_VIDEO");
|
|
}
|
|
if (can(capabilities, CAPABILITY_CAN_PAUSE_VIDEO)) {
|
|
builder.append(" CAPABILITY_CAN_PAUSE_VIDEO");
|
|
}
|
|
builder.append("]");
|
|
return builder.toString();
|
|
}
|
|
|
|
/**
|
|
* Whether the supplied properties includes the specified property.
|
|
*
|
|
* @param properties A bit field of properties.
|
|
* @param property The property to check properties for.
|
|
* @return Whether the specified property is supported.
|
|
*/
|
|
public static boolean hasProperty(int properties, int property) {
|
|
return (properties & property) != 0;
|
|
}
|
|
|
|
/**
|
|
* Whether the properties of this {@code Details} includes the specified property.
|
|
*
|
|
* @param property The property to check properties for.
|
|
* @return Whether the specified property is supported.
|
|
*/
|
|
public boolean hasProperty(int property) {
|
|
return hasProperty(mCallProperties, property);
|
|
}
|
|
|
|
/**
|
|
* Render a set of property bits ({@code PROPERTY_*}) as a human readable string.
|
|
*
|
|
* @param properties A property bit field.
|
|
* @return A human readable string representation.
|
|
*/
|
|
public static String propertiesToString(int properties) {
|
|
StringBuilder builder = new StringBuilder();
|
|
builder.append("[Properties:");
|
|
if (hasProperty(properties, PROPERTY_CONFERENCE)) {
|
|
builder.append(" PROPERTY_CONFERENCE");
|
|
}
|
|
if (hasProperty(properties, PROPERTY_GENERIC_CONFERENCE)) {
|
|
builder.append(" PROPERTY_GENERIC_CONFERENCE");
|
|
}
|
|
if (hasProperty(properties, PROPERTY_WIFI)) {
|
|
builder.append(" PROPERTY_WIFI");
|
|
}
|
|
if (hasProperty(properties, PROPERTY_HIGH_DEF_AUDIO)) {
|
|
builder.append(" PROPERTY_HIGH_DEF_AUDIO");
|
|
}
|
|
if (hasProperty(properties, PROPERTY_EMERGENCY_CALLBACK_MODE)) {
|
|
builder.append(" EMERGENCY_CALLBACK_MODE");
|
|
}
|
|
builder.append("]");
|
|
return builder.toString();
|
|
}
|
|
|
|
/**
|
|
* @return The handle (e.g., phone number) to which the {@code Call} is currently
|
|
* connected.
|
|
*/
|
|
public Uri getHandle() {
|
|
return mHandle;
|
|
}
|
|
|
|
/**
|
|
* @return The presentation requirements for the handle. See
|
|
* {@link TelecomManager} for valid values.
|
|
*/
|
|
public int getHandlePresentation() {
|
|
return mHandlePresentation;
|
|
}
|
|
|
|
/**
|
|
* @return The display name for the caller.
|
|
*/
|
|
public String getCallerDisplayName() {
|
|
return mCallerDisplayName;
|
|
}
|
|
|
|
/**
|
|
* @return The presentation requirements for the caller display name. See
|
|
* {@link TelecomManager} for valid values.
|
|
*/
|
|
public int getCallerDisplayNamePresentation() {
|
|
return mCallerDisplayNamePresentation;
|
|
}
|
|
|
|
/**
|
|
* @return The {@code PhoneAccountHandle} whereby the {@code Call} is currently being
|
|
* routed.
|
|
*/
|
|
public PhoneAccountHandle getAccountHandle() {
|
|
return mAccountHandle;
|
|
}
|
|
|
|
/**
|
|
* @return A bitmask of the capabilities of the {@code Call}, as defined by the various
|
|
* {@code CAPABILITY_*} constants in this class.
|
|
*/
|
|
public int getCallCapabilities() {
|
|
return mCallCapabilities;
|
|
}
|
|
|
|
/**
|
|
* @return A bitmask of the properties of the {@code Call}, as defined by the various
|
|
* {@code PROPERTY_*} constants in this class.
|
|
*/
|
|
public int getCallProperties() {
|
|
return mCallProperties;
|
|
}
|
|
|
|
/**
|
|
* @return For a {@link #STATE_DISCONNECTED} {@code Call}, the disconnect cause expressed
|
|
* by {@link android.telecom.DisconnectCause}.
|
|
*/
|
|
public DisconnectCause getDisconnectCause() {
|
|
return mDisconnectCause;
|
|
}
|
|
|
|
/**
|
|
* @return The time the {@code Call} has been connected. This information is updated
|
|
* periodically, but user interfaces should not rely on this to display any "call time
|
|
* clock".
|
|
*/
|
|
public final long getConnectTimeMillis() {
|
|
return mConnectTimeMillis;
|
|
}
|
|
|
|
/**
|
|
* @return Information about any calling gateway the {@code Call} may be using.
|
|
*/
|
|
public GatewayInfo getGatewayInfo() {
|
|
return mGatewayInfo;
|
|
}
|
|
|
|
/**
|
|
* @return The video state of the {@code Call}.
|
|
*/
|
|
public int getVideoState() {
|
|
return mVideoState;
|
|
}
|
|
|
|
/**
|
|
* @return The current {@link android.telecom.StatusHints}, or {@code null} if none
|
|
* have been set.
|
|
*/
|
|
public StatusHints getStatusHints() {
|
|
return mStatusHints;
|
|
}
|
|
|
|
/**
|
|
* @return A bundle extras to pass with the call
|
|
*/
|
|
public Bundle getExtras() {
|
|
return mExtras;
|
|
}
|
|
|
|
@Override
|
|
public boolean equals(Object o) {
|
|
if (o instanceof Details) {
|
|
Details d = (Details) o;
|
|
return
|
|
Objects.equals(mHandle, d.mHandle) &&
|
|
Objects.equals(mHandlePresentation, d.mHandlePresentation) &&
|
|
Objects.equals(mCallerDisplayName, d.mCallerDisplayName) &&
|
|
Objects.equals(mCallerDisplayNamePresentation,
|
|
d.mCallerDisplayNamePresentation) &&
|
|
Objects.equals(mAccountHandle, d.mAccountHandle) &&
|
|
Objects.equals(mCallCapabilities, d.mCallCapabilities) &&
|
|
Objects.equals(mCallProperties, d.mCallProperties) &&
|
|
Objects.equals(mDisconnectCause, d.mDisconnectCause) &&
|
|
Objects.equals(mConnectTimeMillis, d.mConnectTimeMillis) &&
|
|
Objects.equals(mGatewayInfo, d.mGatewayInfo) &&
|
|
Objects.equals(mVideoState, d.mVideoState) &&
|
|
Objects.equals(mStatusHints, d.mStatusHints) &&
|
|
Objects.equals(mExtras, d.mExtras);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public int hashCode() {
|
|
return
|
|
Objects.hashCode(mHandle) +
|
|
Objects.hashCode(mHandlePresentation) +
|
|
Objects.hashCode(mCallerDisplayName) +
|
|
Objects.hashCode(mCallerDisplayNamePresentation) +
|
|
Objects.hashCode(mAccountHandle) +
|
|
Objects.hashCode(mCallCapabilities) +
|
|
Objects.hashCode(mCallProperties) +
|
|
Objects.hashCode(mDisconnectCause) +
|
|
Objects.hashCode(mConnectTimeMillis) +
|
|
Objects.hashCode(mGatewayInfo) +
|
|
Objects.hashCode(mVideoState) +
|
|
Objects.hashCode(mStatusHints) +
|
|
Objects.hashCode(mExtras);
|
|
}
|
|
|
|
/** {@hide} */
|
|
public Details(
|
|
Uri handle,
|
|
int handlePresentation,
|
|
String callerDisplayName,
|
|
int callerDisplayNamePresentation,
|
|
PhoneAccountHandle accountHandle,
|
|
int capabilities,
|
|
int properties,
|
|
DisconnectCause disconnectCause,
|
|
long connectTimeMillis,
|
|
GatewayInfo gatewayInfo,
|
|
int videoState,
|
|
StatusHints statusHints,
|
|
Bundle extras) {
|
|
mHandle = handle;
|
|
mHandlePresentation = handlePresentation;
|
|
mCallerDisplayName = callerDisplayName;
|
|
mCallerDisplayNamePresentation = callerDisplayNamePresentation;
|
|
mAccountHandle = accountHandle;
|
|
mCallCapabilities = capabilities;
|
|
mCallProperties = properties;
|
|
mDisconnectCause = disconnectCause;
|
|
mConnectTimeMillis = connectTimeMillis;
|
|
mGatewayInfo = gatewayInfo;
|
|
mVideoState = videoState;
|
|
mStatusHints = statusHints;
|
|
mExtras = extras;
|
|
}
|
|
}
|
|
|
|
public static abstract class Callback {
|
|
/**
|
|
* Invoked when the state of this {@code Call} has changed. See {@link #getState()}.
|
|
*
|
|
* @param call The {@code Call} invoking this method.
|
|
* @param state The new state of the {@code Call}.
|
|
*/
|
|
public void onStateChanged(Call call, int state) {}
|
|
|
|
/**
|
|
* Invoked when the parent of this {@code Call} has changed. See {@link #getParent()}.
|
|
*
|
|
* @param call The {@code Call} invoking this method.
|
|
* @param parent The new parent of the {@code Call}.
|
|
*/
|
|
public void onParentChanged(Call call, Call parent) {}
|
|
|
|
/**
|
|
* Invoked when the children of this {@code Call} have changed. See {@link #getChildren()}.
|
|
*
|
|
* @param call The {@code Call} invoking this method.
|
|
* @param children The new children of the {@code Call}.
|
|
*/
|
|
public void onChildrenChanged(Call call, List<Call> children) {}
|
|
|
|
/**
|
|
* Invoked when the details of this {@code Call} have changed. See {@link #getDetails()}.
|
|
*
|
|
* @param call The {@code Call} invoking this method.
|
|
* @param details A {@code Details} object describing the {@code Call}.
|
|
*/
|
|
public void onDetailsChanged(Call call, Details details) {}
|
|
|
|
/**
|
|
* Invoked when the text messages that can be used as responses to the incoming
|
|
* {@code Call} are loaded from the relevant database.
|
|
* See {@link #getCannedTextResponses()}.
|
|
*
|
|
* @param call The {@code Call} invoking this method.
|
|
* @param cannedTextResponses The text messages useable as responses.
|
|
*/
|
|
public void onCannedTextResponsesLoaded(Call call, List<String> cannedTextResponses) {}
|
|
|
|
/**
|
|
* Invoked when the post-dial sequence in the outgoing {@code Call} has reached a pause
|
|
* character. This causes the post-dial signals to stop pending user confirmation. An
|
|
* implementation should present this choice to the user and invoke
|
|
* {@link #postDialContinue(boolean)} when the user makes the choice.
|
|
*
|
|
* @param call The {@code Call} invoking this method.
|
|
* @param remainingPostDialSequence The post-dial characters that remain to be sent.
|
|
*/
|
|
public void onPostDialWait(Call call, String remainingPostDialSequence) {}
|
|
|
|
/**
|
|
* Invoked when the {@code Call.VideoCall} of the {@code Call} has changed.
|
|
*
|
|
* @param call The {@code Call} invoking this method.
|
|
* @param videoCall The {@code Call.VideoCall} associated with the {@code Call}.
|
|
*/
|
|
public void onVideoCallChanged(Call call, InCallService.VideoCall videoCall) {}
|
|
|
|
/**
|
|
* Invoked when the {@code Call} is destroyed. Clients should refrain from cleaning
|
|
* up their UI for the {@code Call} in response to state transitions. Specifically,
|
|
* clients should not assume that a {@link #onStateChanged(Call, int)} with a state of
|
|
* {@link #STATE_DISCONNECTED} is the final notification the {@code Call} will send. Rather,
|
|
* clients should wait for this method to be invoked.
|
|
*
|
|
* @param call The {@code Call} being destroyed.
|
|
*/
|
|
public void onCallDestroyed(Call call) {}
|
|
|
|
/**
|
|
* Invoked upon changes to the set of {@code Call}s with which this {@code Call} can be
|
|
* conferenced.
|
|
*
|
|
* @param call The {@code Call} being updated.
|
|
* @param conferenceableCalls The {@code Call}s with which this {@code Call} can be
|
|
* conferenced.
|
|
*/
|
|
public void onConferenceableCallsChanged(Call call, List<Call> conferenceableCalls) {}
|
|
}
|
|
|
|
/**
|
|
* @deprecated Use {@code Call.Callback} instead.
|
|
* @hide
|
|
*/
|
|
@Deprecated
|
|
@SystemApi
|
|
public static abstract class Listener extends Callback { }
|
|
|
|
private final Phone mPhone;
|
|
private final String mTelecomCallId;
|
|
private final InCallAdapter mInCallAdapter;
|
|
private final List<String> mChildrenIds = new ArrayList<>();
|
|
private final List<Call> mChildren = new ArrayList<>();
|
|
private final List<Call> mUnmodifiableChildren = Collections.unmodifiableList(mChildren);
|
|
private final List<CallbackRecord<Callback>> mCallbackRecords = new CopyOnWriteArrayList<>();
|
|
private final List<Call> mConferenceableCalls = new ArrayList<>();
|
|
private final List<Call> mUnmodifiableConferenceableCalls =
|
|
Collections.unmodifiableList(mConferenceableCalls);
|
|
|
|
private boolean mChildrenCached;
|
|
private String mParentId = null;
|
|
private int mState;
|
|
private List<String> mCannedTextResponses = null;
|
|
private String mRemainingPostDialSequence;
|
|
private InCallService.VideoCall mVideoCall;
|
|
private Details mDetails;
|
|
|
|
/**
|
|
* Obtains the post-dial sequence remaining to be emitted by this {@code Call}, if any.
|
|
*
|
|
* @return The remaining post-dial sequence, or {@code null} if there is no post-dial sequence
|
|
* remaining or this {@code Call} is not in a post-dial state.
|
|
*/
|
|
public String getRemainingPostDialSequence() {
|
|
return mRemainingPostDialSequence;
|
|
}
|
|
|
|
/**
|
|
* Instructs this {@link #STATE_RINGING} {@code Call} to answer.
|
|
* @param videoState The video state in which to answer the call.
|
|
*/
|
|
public void answer(int videoState) {
|
|
mInCallAdapter.answerCall(mTelecomCallId, videoState);
|
|
}
|
|
|
|
/**
|
|
* Instructs this {@link #STATE_RINGING} {@code Call} to reject.
|
|
*
|
|
* @param rejectWithMessage Whether to reject with a text message.
|
|
* @param textMessage An optional text message with which to respond.
|
|
*/
|
|
public void reject(boolean rejectWithMessage, String textMessage) {
|
|
mInCallAdapter.rejectCall(mTelecomCallId, rejectWithMessage, textMessage);
|
|
}
|
|
|
|
/**
|
|
* Instructs this {@code Call} to disconnect.
|
|
*/
|
|
public void disconnect() {
|
|
mInCallAdapter.disconnectCall(mTelecomCallId);
|
|
}
|
|
|
|
/**
|
|
* Instructs this {@code Call} to go on hold.
|
|
*/
|
|
public void hold() {
|
|
mInCallAdapter.holdCall(mTelecomCallId);
|
|
}
|
|
|
|
/**
|
|
* Instructs this {@link #STATE_HOLDING} call to release from hold.
|
|
*/
|
|
public void unhold() {
|
|
mInCallAdapter.unholdCall(mTelecomCallId);
|
|
}
|
|
|
|
/**
|
|
* Instructs this {@code Call} to play a dual-tone multi-frequency signaling (DTMF) tone.
|
|
*
|
|
* Any other currently playing DTMF tone in the specified call is immediately stopped.
|
|
*
|
|
* @param digit A character representing the DTMF digit for which to play the tone. This
|
|
* value must be one of {@code '0'} through {@code '9'}, {@code '*'} or {@code '#'}.
|
|
*/
|
|
public void playDtmfTone(char digit) {
|
|
mInCallAdapter.playDtmfTone(mTelecomCallId, digit);
|
|
}
|
|
|
|
/**
|
|
* Instructs this {@code Call} to stop any dual-tone multi-frequency signaling (DTMF) tone
|
|
* currently playing.
|
|
*
|
|
* DTMF tones are played by calling {@link #playDtmfTone(char)}. If no DTMF tone is
|
|
* currently playing, this method will do nothing.
|
|
*/
|
|
public void stopDtmfTone() {
|
|
mInCallAdapter.stopDtmfTone(mTelecomCallId);
|
|
}
|
|
|
|
/**
|
|
* Instructs this {@code Call} to continue playing a post-dial DTMF string.
|
|
*
|
|
* A post-dial DTMF string is a string of digits entered after a phone number, when dialed,
|
|
* that are immediately sent as DTMF tones to the recipient as soon as the connection is made.
|
|
*
|
|
* If the DTMF string contains a {@link TelecomManager#DTMF_CHARACTER_PAUSE} symbol, this
|
|
* {@code Call} will temporarily pause playing the tones for a pre-defined period of time.
|
|
*
|
|
* If the DTMF string contains a {@link TelecomManager#DTMF_CHARACTER_WAIT} symbol, this
|
|
* {@code Call} will pause playing the tones and notify callbacks via
|
|
* {@link Callback#onPostDialWait(Call, String)}. At this point, the in-call app
|
|
* should display to the user an indication of this state and an affordance to continue
|
|
* the postdial sequence. When the user decides to continue the postdial sequence, the in-call
|
|
* app should invoke the {@link #postDialContinue(boolean)} method.
|
|
*
|
|
* @param proceed Whether or not to continue with the post-dial sequence.
|
|
*/
|
|
public void postDialContinue(boolean proceed) {
|
|
mInCallAdapter.postDialContinue(mTelecomCallId, proceed);
|
|
}
|
|
|
|
/**
|
|
* Notifies this {@code Call} that an account has been selected and to proceed with placing
|
|
* an outgoing call. Optionally sets this account as the default account.
|
|
*/
|
|
public void phoneAccountSelected(PhoneAccountHandle accountHandle, boolean setDefault) {
|
|
mInCallAdapter.phoneAccountSelected(mTelecomCallId, accountHandle, setDefault);
|
|
|
|
}
|
|
|
|
/**
|
|
* Instructs this {@code Call} to enter a conference.
|
|
*
|
|
* @param callToConferenceWith The other call with which to conference.
|
|
*/
|
|
public void conference(Call callToConferenceWith) {
|
|
if (callToConferenceWith != null) {
|
|
mInCallAdapter.conference(mTelecomCallId, callToConferenceWith.mTelecomCallId);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Instructs this {@code Call} to split from any conference call with which it may be
|
|
* connected.
|
|
*/
|
|
public void splitFromConference() {
|
|
mInCallAdapter.splitFromConference(mTelecomCallId);
|
|
}
|
|
|
|
/**
|
|
* Merges the calls within this conference. See {@link Details#CAPABILITY_MERGE_CONFERENCE}.
|
|
*/
|
|
public void mergeConference() {
|
|
mInCallAdapter.mergeConference(mTelecomCallId);
|
|
}
|
|
|
|
/**
|
|
* Swaps the calls within this conference. See {@link Details#CAPABILITY_SWAP_CONFERENCE}.
|
|
*/
|
|
public void swapConference() {
|
|
mInCallAdapter.swapConference(mTelecomCallId);
|
|
}
|
|
|
|
/**
|
|
* Obtains the parent of this {@code Call} in a conference, if any.
|
|
*
|
|
* @return The parent {@code Call}, or {@code null} if this {@code Call} is not a
|
|
* child of any conference {@code Call}s.
|
|
*/
|
|
public Call getParent() {
|
|
if (mParentId != null) {
|
|
return mPhone.internalGetCallByTelecomId(mParentId);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Obtains the children of this conference {@code Call}, if any.
|
|
*
|
|
* @return The children of this {@code Call} if this {@code Call} is a conference, or an empty
|
|
* {@code List} otherwise.
|
|
*/
|
|
public List<Call> getChildren() {
|
|
if (!mChildrenCached) {
|
|
mChildrenCached = true;
|
|
mChildren.clear();
|
|
|
|
for(String id : mChildrenIds) {
|
|
Call call = mPhone.internalGetCallByTelecomId(id);
|
|
if (call == null) {
|
|
// At least one child was still not found, so do not save true for "cached"
|
|
mChildrenCached = false;
|
|
} else {
|
|
mChildren.add(call);
|
|
}
|
|
}
|
|
}
|
|
|
|
return mUnmodifiableChildren;
|
|
}
|
|
|
|
/**
|
|
* Returns the list of {@code Call}s with which this {@code Call} is allowed to conference.
|
|
*
|
|
* @return The list of conferenceable {@code Call}s.
|
|
*/
|
|
public List<Call> getConferenceableCalls() {
|
|
return mUnmodifiableConferenceableCalls;
|
|
}
|
|
|
|
/**
|
|
* Obtains the state of this {@code Call}.
|
|
*
|
|
* @return A state value, chosen from the {@code STATE_*} constants.
|
|
*/
|
|
public int getState() {
|
|
return mState;
|
|
}
|
|
|
|
/**
|
|
* Obtains a list of canned, pre-configured message responses to present to the user as
|
|
* ways of rejecting this {@code Call} using via a text message.
|
|
*
|
|
* @see #reject(boolean, String)
|
|
*
|
|
* @return A list of canned text message responses.
|
|
*/
|
|
public List<String> getCannedTextResponses() {
|
|
return mCannedTextResponses;
|
|
}
|
|
|
|
/**
|
|
* Obtains an object that can be used to display video from this {@code Call}.
|
|
*
|
|
* @return An {@code Call.VideoCall}.
|
|
*/
|
|
public InCallService.VideoCall getVideoCall() {
|
|
return mVideoCall;
|
|
}
|
|
|
|
/**
|
|
* Obtains an object containing call details.
|
|
*
|
|
* @return A {@link Details} object. Depending on the state of the {@code Call}, the
|
|
* result may be {@code null}.
|
|
*/
|
|
public Details getDetails() {
|
|
return mDetails;
|
|
}
|
|
|
|
/**
|
|
* Registers a callback to this {@code Call}.
|
|
*
|
|
* @param callback A {@code Callback}.
|
|
*/
|
|
public void registerCallback(Callback callback) {
|
|
registerCallback(callback, new Handler());
|
|
}
|
|
|
|
/**
|
|
* Registers a callback to this {@code Call}.
|
|
*
|
|
* @param callback A {@code Callback}.
|
|
* @param handler A handler which command and status changes will be delivered to.
|
|
*/
|
|
public void registerCallback(Callback callback, Handler handler) {
|
|
unregisterCallback(callback);
|
|
if (callback != null && handler != null) {
|
|
mCallbackRecords.add(new CallbackRecord<Callback>(callback, handler));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Unregisters a callback from this {@code Call}.
|
|
*
|
|
* @param callback A {@code Callback}.
|
|
*/
|
|
public void unregisterCallback(Callback callback) {
|
|
if (callback != null) {
|
|
for (CallbackRecord<Callback> record : mCallbackRecords) {
|
|
if (record.getCallback() == callback) {
|
|
mCallbackRecords.remove(record);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Adds a listener to this {@code Call}.
|
|
*
|
|
* @param listener A {@code Listener}.
|
|
* @deprecated Use {@link #registerCallback} instead.
|
|
* @hide
|
|
*/
|
|
@Deprecated
|
|
@SystemApi
|
|
public void addListener(Listener listener) {
|
|
registerCallback(listener);
|
|
}
|
|
|
|
/**
|
|
* Removes a listener from this {@code Call}.
|
|
*
|
|
* @param listener A {@code Listener}.
|
|
* @deprecated Use {@link #unregisterCallback} instead.
|
|
* @hide
|
|
*/
|
|
@Deprecated
|
|
@SystemApi
|
|
public void removeListener(Listener listener) {
|
|
unregisterCallback(listener);
|
|
}
|
|
|
|
|
|
/** {@hide} */
|
|
Call(Phone phone, String telecomCallId, InCallAdapter inCallAdapter) {
|
|
mPhone = phone;
|
|
mTelecomCallId = telecomCallId;
|
|
mInCallAdapter = inCallAdapter;
|
|
mState = STATE_NEW;
|
|
}
|
|
|
|
/** {@hide} */
|
|
final String internalGetCallId() {
|
|
return mTelecomCallId;
|
|
}
|
|
|
|
/** {@hide} */
|
|
final void internalUpdate(ParcelableCall parcelableCall, Map<String, Call> callIdMap) {
|
|
// First, we update the internal state as far as possible before firing any updates.
|
|
Details details = new Details(
|
|
parcelableCall.getHandle(),
|
|
parcelableCall.getHandlePresentation(),
|
|
parcelableCall.getCallerDisplayName(),
|
|
parcelableCall.getCallerDisplayNamePresentation(),
|
|
parcelableCall.getAccountHandle(),
|
|
parcelableCall.getCapabilities(),
|
|
parcelableCall.getProperties(),
|
|
parcelableCall.getDisconnectCause(),
|
|
parcelableCall.getConnectTimeMillis(),
|
|
parcelableCall.getGatewayInfo(),
|
|
parcelableCall.getVideoState(),
|
|
parcelableCall.getStatusHints(),
|
|
parcelableCall.getExtras());
|
|
boolean detailsChanged = !Objects.equals(mDetails, details);
|
|
if (detailsChanged) {
|
|
mDetails = details;
|
|
}
|
|
|
|
boolean cannedTextResponsesChanged = false;
|
|
if (mCannedTextResponses == null && parcelableCall.getCannedSmsResponses() != null
|
|
&& !parcelableCall.getCannedSmsResponses().isEmpty()) {
|
|
mCannedTextResponses =
|
|
Collections.unmodifiableList(parcelableCall.getCannedSmsResponses());
|
|
}
|
|
|
|
boolean videoCallChanged = parcelableCall.isVideoCallProviderChanged() &&
|
|
!Objects.equals(mVideoCall, parcelableCall.getVideoCall(this));
|
|
if (videoCallChanged) {
|
|
mVideoCall = parcelableCall.getVideoCall(this);
|
|
}
|
|
|
|
int state = parcelableCall.getState();
|
|
boolean stateChanged = mState != state;
|
|
if (stateChanged) {
|
|
mState = state;
|
|
}
|
|
|
|
String parentId = parcelableCall.getParentCallId();
|
|
boolean parentChanged = !Objects.equals(mParentId, parentId);
|
|
if (parentChanged) {
|
|
mParentId = parentId;
|
|
}
|
|
|
|
List<String> childCallIds = parcelableCall.getChildCallIds();
|
|
boolean childrenChanged = !Objects.equals(childCallIds, mChildrenIds);
|
|
if (childrenChanged) {
|
|
mChildrenIds.clear();
|
|
mChildrenIds.addAll(parcelableCall.getChildCallIds());
|
|
mChildrenCached = false;
|
|
}
|
|
|
|
List<String> conferenceableCallIds = parcelableCall.getConferenceableCallIds();
|
|
List<Call> conferenceableCalls = new ArrayList<Call>(conferenceableCallIds.size());
|
|
for (String otherId : conferenceableCallIds) {
|
|
if (callIdMap.containsKey(otherId)) {
|
|
conferenceableCalls.add(callIdMap.get(otherId));
|
|
}
|
|
}
|
|
|
|
if (!Objects.equals(mConferenceableCalls, conferenceableCalls)) {
|
|
mConferenceableCalls.clear();
|
|
mConferenceableCalls.addAll(conferenceableCalls);
|
|
fireConferenceableCallsChanged();
|
|
}
|
|
|
|
// Now we fire updates, ensuring that any client who listens to any of these notifications
|
|
// gets the most up-to-date state.
|
|
|
|
if (stateChanged) {
|
|
fireStateChanged(mState);
|
|
}
|
|
if (detailsChanged) {
|
|
fireDetailsChanged(mDetails);
|
|
}
|
|
if (cannedTextResponsesChanged) {
|
|
fireCannedTextResponsesLoaded(mCannedTextResponses);
|
|
}
|
|
if (videoCallChanged) {
|
|
fireVideoCallChanged(mVideoCall);
|
|
}
|
|
if (parentChanged) {
|
|
fireParentChanged(getParent());
|
|
}
|
|
if (childrenChanged) {
|
|
fireChildrenChanged(getChildren());
|
|
}
|
|
|
|
// If we have transitioned to DISCONNECTED, that means we need to notify clients and
|
|
// remove ourselves from the Phone. Note that we do this after completing all state updates
|
|
// so a client can cleanly transition all their UI to the state appropriate for a
|
|
// DISCONNECTED Call while still relying on the existence of that Call in the Phone's list.
|
|
if (mState == STATE_DISCONNECTED) {
|
|
fireCallDestroyed();
|
|
mPhone.internalRemoveCall(this);
|
|
}
|
|
}
|
|
|
|
/** {@hide} */
|
|
final void internalSetPostDialWait(String remaining) {
|
|
mRemainingPostDialSequence = remaining;
|
|
firePostDialWait(mRemainingPostDialSequence);
|
|
}
|
|
|
|
/** {@hide} */
|
|
final void internalSetDisconnected() {
|
|
if (mState != Call.STATE_DISCONNECTED) {
|
|
mState = Call.STATE_DISCONNECTED;
|
|
fireStateChanged(mState);
|
|
fireCallDestroyed();
|
|
mPhone.internalRemoveCall(this);
|
|
}
|
|
}
|
|
|
|
private void fireStateChanged(final int newState) {
|
|
for (CallbackRecord<Callback> record : mCallbackRecords) {
|
|
final Call call = this;
|
|
final Callback callback = record.getCallback();
|
|
record.getHandler().post(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
callback.onStateChanged(call, newState);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
private void fireParentChanged(final Call newParent) {
|
|
for (CallbackRecord<Callback> record : mCallbackRecords) {
|
|
final Call call = this;
|
|
final Callback callback = record.getCallback();
|
|
record.getHandler().post(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
callback.onParentChanged(call, newParent);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
private void fireChildrenChanged(final List<Call> children) {
|
|
for (CallbackRecord<Callback> record : mCallbackRecords) {
|
|
final Call call = this;
|
|
final Callback callback = record.getCallback();
|
|
record.getHandler().post(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
callback.onChildrenChanged(call, children);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
private void fireDetailsChanged(final Details details) {
|
|
for (CallbackRecord<Callback> record : mCallbackRecords) {
|
|
final Call call = this;
|
|
final Callback callback = record.getCallback();
|
|
record.getHandler().post(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
callback.onDetailsChanged(call, details);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
private void fireCannedTextResponsesLoaded(final List<String> cannedTextResponses) {
|
|
for (CallbackRecord<Callback> record : mCallbackRecords) {
|
|
final Call call = this;
|
|
final Callback callback = record.getCallback();
|
|
record.getHandler().post(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
callback.onCannedTextResponsesLoaded(call, cannedTextResponses);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
private void fireVideoCallChanged(final InCallService.VideoCall videoCall) {
|
|
for (CallbackRecord<Callback> record : mCallbackRecords) {
|
|
final Call call = this;
|
|
final Callback callback = record.getCallback();
|
|
record.getHandler().post(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
callback.onVideoCallChanged(call, videoCall);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
private void firePostDialWait(final String remainingPostDialSequence) {
|
|
for (CallbackRecord<Callback> record : mCallbackRecords) {
|
|
final Call call = this;
|
|
final Callback callback = record.getCallback();
|
|
record.getHandler().post(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
callback.onPostDialWait(call, remainingPostDialSequence);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
private void fireCallDestroyed() {
|
|
for (CallbackRecord<Callback> record: mCallbackRecords) {
|
|
final Call call = this;
|
|
final Callback callback = record.getCallback();
|
|
record.getHandler().post(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
callback.onCallDestroyed(call);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
private void fireConferenceableCallsChanged() {
|
|
for (CallbackRecord<Callback> record : mCallbackRecords) {
|
|
final Call call = this;
|
|
final Callback callback = record.getCallback();
|
|
record.getHandler().post(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
callback.onConferenceableCallsChanged(call, mUnmodifiableConferenceableCalls);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}
|